Unchecked

java.lang.Object
- org.jooq.lambda.Unchecked

```
public final class Unchecked
extends Object
```
Improved interoperability between checked exceptions and Java 8.
Checked exceptions are one of Java's biggest flaws. Due to backwards-compatibility, we're inheriting all the checked exception trouble back from JDK 1.0. This becomes even more obvious when using lambda expressions, most of which are not allowed to throw checked exceptions.

This library tries to ease some pain and wraps / unwraps a variety of API elements from the JDK 8 to improve interoperability with checked exceptions.

Field Summary

Fields

Modifier and Type	Field and Description
`static Consumer<Throwable>`	`THROWABLE_TO_RUNTIME_EXCEPTION` A `Consumer` that wraps any `Throwable` in a `RuntimeException`.

Method Summary

Methods

Modifier and Type	Method and Description
`static <T,U> BiConsumer<T,U>`	`biConsumer(CheckedBiConsumer<T,U> consumer)` Wrap a `CheckedBiConsumer` in a `BiConsumer`.
`static <T,U> BiConsumer<T,U>`	`biConsumer(CheckedBiConsumer<T,U> consumer, Consumer<Throwable> handler)` Wrap a `CheckedBiConsumer` in a `BiConsumer` with a custom handler for checked exceptions.
`static <T,U,R> BiFunction<T,U,R>`	`biFunction(CheckedBiFunction<T,U,R> function)` Wrap a `CheckedBiFunction` in a `BiFunction`.
`static <T,U,R> BiFunction<T,U,R>`	`biFunction(CheckedBiFunction<T,U,R> function, Consumer<Throwable> handler)` Wrap a `CheckedBiFunction` in a `BiFunction` with a custom handler for checked exceptions.
`static <T> BinaryOperator<T>`	`binaryOperator(CheckedBinaryOperator<T> operator)` Wrap a `CheckedBinaryOperator` in a `BinaryOperator`.
`static <T> BinaryOperator<T>`	`binaryOperator(CheckedBinaryOperator<T> operator, Consumer<Throwable> handler)` Wrap a `CheckedBinaryOperator` in a `BinaryOperator` with a custom handler for checked exceptions.
`static <T,U> BiPredicate<T,U>`	`biPredicate(CheckedBiPredicate<T,U> predicate)` Wrap a `CheckedBiPredicate` in a `BiPredicate`.
`static <T,U> BiPredicate<T,U>`	`biPredicate(CheckedBiPredicate<T,U> predicate, Consumer<Throwable> handler)` Wrap a `CheckedBiPredicate` in a `BiPredicate` with a custom handler for checked exceptions.
`static BooleanSupplier`	`booleanSupplier(CheckedBooleanSupplier supplier)` Wrap a `CheckedBooleanSupplier` in a `BooleanSupplier`.
`static BooleanSupplier`	`booleanSupplier(CheckedBooleanSupplier supplier, Consumer<Throwable> handler)` Wrap a `CheckedBooleanSupplier` in a `BooleanSupplier` with a custom handler for checked exceptions.
`static <T> Comparator<T>`	`comparator(CheckedComparator<T> comparator)` Wrap a `CheckedComparator` in a `Comparator`.
`static <T> Comparator<T>`	`comparator(CheckedComparator<T> comparator, Consumer<Throwable> handler)` Wrap a `CheckedComparator` in a `Comparator` with a custom handler for checked exceptions.
`static <T> Consumer<T>`	`consumer(CheckedConsumer<T> consumer)` Wrap a `CheckedConsumer` in a `Consumer`.
`static <T> Consumer<T>`	`consumer(CheckedConsumer<T> consumer, Consumer<Throwable> handler)` Wrap a `CheckedConsumer` in a `Consumer` with a custom handler for checked exceptions.
`static DoubleBinaryOperator`	`doubleBinaryOperator(CheckedDoubleBinaryOperator operator)` Wrap a `CheckedDoubleBinaryOperator` in a `DoubleBinaryOperator`.
`static DoubleBinaryOperator`	`doubleBinaryOperator(CheckedDoubleBinaryOperator operator, Consumer<Throwable> handler)` Wrap a `CheckedDoubleBinaryOperator` in a `DoubleBinaryOperator` with a custom handler for checked exceptions.
`static DoubleConsumer`	`doubleConsumer(CheckedDoubleConsumer consumer)` Wrap a `CheckedDoubleConsumer` in a `DoubleConsumer`.
`static DoubleConsumer`	`doubleConsumer(CheckedDoubleConsumer consumer, Consumer<Throwable> handler)` Wrap a `CheckedDoubleConsumer` in a `DoubleConsumer` with a custom handler for checked exceptions.
`static <R> DoubleFunction<R>`	`doubleFunction(CheckedDoubleFunction<R> function)` Wrap a `CheckedDoubleFunction` in a `DoubleFunction`.
`static <R> DoubleFunction<R>`	`doubleFunction(CheckedDoubleFunction<R> function, Consumer<Throwable> handler)` Wrap a `CheckedDoubleFunction` in a `DoubleFunction` with a custom handler for checked exceptions.
`static DoublePredicate`	`doublePredicate(CheckedDoublePredicate predicate)` Wrap a `CheckedDoublePredicate` in a `DoublePredicate`.
`static DoublePredicate`	`doublePredicate(CheckedDoublePredicate function, Consumer<Throwable> handler)` Wrap a `CheckedDoublePredicate` in a `DoublePredicate` with a custom handler for checked exceptions.
`static DoubleSupplier`	`doubleSupplier(CheckedDoubleSupplier supplier)` Wrap a `CheckedDoubleSupplier` in a `DoubleSupplier`.
`static DoubleSupplier`	`doubleSupplier(CheckedDoubleSupplier supplier, Consumer<Throwable> handler)` Wrap a `CheckedDoubleSupplier` in a `DoubleSupplier` with a custom handler for checked exceptions.
`static DoubleToIntFunction`	`doubleToIntFunction(CheckedDoubleToIntFunction function)` Wrap a `CheckedDoubleToIntFunction` in a `DoubleToIntFunction`.
`static DoubleToIntFunction`	`doubleToIntFunction(CheckedDoubleToIntFunction function, Consumer<Throwable> handler)` Wrap a `CheckedDoubleToIntFunction` in a `DoubleToIntFunction` with a custom handler for checked exceptions.
`static DoubleToLongFunction`	`doubleToLongFunction(CheckedDoubleToLongFunction function)` Wrap a `CheckedDoubleToLongFunction` in a `DoubleToLongFunction`.
`static DoubleToLongFunction`	`doubleToLongFunction(CheckedDoubleToLongFunction function, Consumer<Throwable> handler)` Wrap a `CheckedDoubleToLongFunction` in a `DoubleToLongFunction` with a custom handler for checked exceptions.
`static DoubleUnaryOperator`	`doubleUnaryOperator(CheckedDoubleUnaryOperator operator)` Wrap a `CheckedDoubleUnaryOperator` in a `DoubleUnaryOperator`.
`static DoubleUnaryOperator`	`doubleUnaryOperator(CheckedDoubleUnaryOperator operator, Consumer<Throwable> handler)` Wrap a `CheckedDoubleUnaryOperator` in a `DoubleUnaryOperator` with a custom handler for checked exceptions.
`static <T,R> Function<T,R>`	`function(CheckedFunction<T,R> function)` Wrap a `CheckedFunction` in a `Function`.
`static <T,R> Function<T,R>`	`function(CheckedFunction<T,R> function, Consumer<Throwable> handler)` Wrap a `CheckedFunction` in a `Function` with a custom handler for checked exceptions.
`static IntBinaryOperator`	`intBinaryOperator(CheckedIntBinaryOperator operator)` Wrap a `CheckedIntBinaryOperator` in a `IntBinaryOperator`.
`static IntBinaryOperator`	`intBinaryOperator(CheckedIntBinaryOperator operator, Consumer<Throwable> handler)` Wrap a `CheckedIntBinaryOperator` in a `IntBinaryOperator` with a custom handler for checked exceptions.
`static IntConsumer`	`intConsumer(CheckedIntConsumer consumer)` Wrap a `CheckedIntConsumer` in a `IntConsumer`.
`static IntConsumer`	`intConsumer(CheckedIntConsumer consumer, Consumer<Throwable> handler)` Wrap a `CheckedIntConsumer` in a `IntConsumer` with a custom handler for checked exceptions.
`static <R> IntFunction<R>`	`intFunction(CheckedIntFunction<R> function)` Wrap a `CheckedIntFunction` in a `IntFunction`.
`static <R> IntFunction<R>`	`intFunction(CheckedIntFunction<R> function, Consumer<Throwable> handler)` Wrap a `CheckedIntFunction` in a `IntFunction` with a custom handler for checked exceptions.
`static IntPredicate`	`intPredicate(CheckedIntPredicate predicate)` Wrap a `CheckedPredicate` in a `IntPredicate`.
`static IntPredicate`	`intPredicate(CheckedIntPredicate function, Consumer<Throwable> handler)` Wrap a `CheckedPredicate` in a `IntPredicate` with a custom handler for checked exceptions.
`static IntSupplier`	`intSupplier(CheckedIntSupplier supplier)` Wrap a `CheckedIntSupplier` in a `IntSupplier`.
`static IntSupplier`	`intSupplier(CheckedIntSupplier supplier, Consumer<Throwable> handler)` Wrap a `CheckedIntSupplier` in a `IntSupplier` with a custom handler for checked exceptions.
`static IntToDoubleFunction`	`intToDoubleFunction(CheckedIntToDoubleFunction function)` Wrap a `CheckedIntToDoubleFunction` in a `IntToDoubleFunction`.
`static IntToDoubleFunction`	`intToDoubleFunction(CheckedIntToDoubleFunction function, Consumer<Throwable> handler)` Wrap a `CheckedIntToDoubleFunction` in a `IntToDoubleFunction` with a custom handler for checked exceptions.
`static IntToLongFunction`	`intToLongFunction(CheckedIntToLongFunction function)` Wrap a `CheckedIntToLongFunction` in a `IntToLongFunction`.
`static IntToLongFunction`	`intToLongFunction(CheckedIntToLongFunction function, Consumer<Throwable> handler)` Wrap a `CheckedIntToLongFunction` in a `IntToLongFunction` with a custom handler for checked exceptions.
`static IntUnaryOperator`	`intUnaryOperator(CheckedIntUnaryOperator operator)` Wrap a `CheckedIntUnaryOperator` in a `IntUnaryOperator`.
`static IntUnaryOperator`	`intUnaryOperator(CheckedIntUnaryOperator operator, Consumer<Throwable> handler)` Wrap a `CheckedIntUnaryOperator` in a `IntUnaryOperator` with a custom handler for checked exceptions.
`static LongBinaryOperator`	`longBinaryOperator(CheckedLongBinaryOperator operator)` Wrap a `CheckedLongBinaryOperator` in a `LongBinaryOperator`.
`static LongBinaryOperator`	`longBinaryOperator(CheckedLongBinaryOperator operator, Consumer<Throwable> handler)` Wrap a `CheckedLongBinaryOperator` in a `LongBinaryOperator` with a custom handler for checked exceptions.
`static LongConsumer`	`longConsumer(CheckedLongConsumer consumer)` Wrap a `CheckedLongConsumer` in a `LongConsumer`.
`static LongConsumer`	`longConsumer(CheckedLongConsumer consumer, Consumer<Throwable> handler)` Wrap a `CheckedLongConsumer` in a `LongConsumer` with a custom handler for checked exceptions.
`static <R> LongFunction<R>`	`longFunction(CheckedLongFunction<R> function)` Wrap a `CheckedLongFunction` in a `LongFunction`.
`static <R> LongFunction<R>`	`longFunction(CheckedLongFunction<R> function, Consumer<Throwable> handler)` Wrap a `CheckedLongFunction` in a `LongFunction` with a custom handler for checked exceptions.
`static LongPredicate`	`longPredicate(CheckedLongPredicate predicate)` Wrap a `CheckedLongPredicate` in a `LongPredicate`.
`static LongPredicate`	`longPredicate(CheckedLongPredicate function, Consumer<Throwable> handler)` Wrap a `CheckedLongPredicate` in a `LongPredicate` with a custom handler for checked exceptions.
`static LongSupplier`	`longSupplier(CheckedLongSupplier supplier)` Wrap a `CheckedLongSupplier` in a `LongSupplier`.
`static LongSupplier`	`longSupplier(CheckedLongSupplier supplier, Consumer<Throwable> handler)` Wrap a `CheckedLongSupplier` in a `LongSupplier` with a custom handler for checked exceptions.
`static LongToDoubleFunction`	`longToDoubleFunction(CheckedLongToDoubleFunction function)` Wrap a `CheckedLongToDoubleFunction` in a `LongToDoubleFunction`.
`static LongToDoubleFunction`	`longToDoubleFunction(CheckedLongToDoubleFunction function, Consumer<Throwable> handler)` Wrap a `CheckedLongToDoubleFunction` in a `LongToDoubleFunction` with a custom handler for checked exceptions.
`static LongToIntFunction`	`longToIntFunction(CheckedLongToIntFunction function)` Wrap a `CheckedLongToIntFunction` in a `LongToIntFunction`.
`static LongToIntFunction`	`longToIntFunction(CheckedLongToIntFunction function, Consumer<Throwable> handler)` Wrap a `CheckedLongToIntFunction` in a `LongToIntFunction` with a custom handler for checked exceptions.
`static LongUnaryOperator`	`longUnaryOperator(CheckedLongUnaryOperator operator)` Wrap a `CheckedLongUnaryOperator` in a `LongUnaryOperator`.
`static LongUnaryOperator`	`longUnaryOperator(CheckedLongUnaryOperator operator, Consumer<Throwable> handler)` Wrap a `CheckedLongUnaryOperator` in a `LongUnaryOperator` with a custom handler for checked exceptions.
`static <T> ObjDoubleConsumer<T>`	`objDoubleConsumer(CheckedObjDoubleConsumer<T> consumer)` Wrap a `CheckedObjDoubleConsumer` in a `ObjDoubleConsumer`.
`static <T> ObjDoubleConsumer<T>`	`objDoubleConsumer(CheckedObjDoubleConsumer<T> consumer, Consumer<Throwable> handler)` Wrap a `CheckedObjDoubleConsumer` in a `ObjDoubleConsumer` with a custom handler for checked exceptions.
`static <T> ObjIntConsumer<T>`	`objIntConsumer(CheckedObjIntConsumer<T> consumer)` Wrap a `CheckedObjIntConsumer` in a `ObjIntConsumer`.
`static <T> ObjIntConsumer<T>`	`objIntConsumer(CheckedObjIntConsumer<T> consumer, Consumer<Throwable> handler)` Wrap a `CheckedObjIntConsumer` in a `ObjIntConsumer` with a custom handler for checked exceptions.
`static <T> ObjLongConsumer<T>`	`objLongConsumer(CheckedObjLongConsumer<T> consumer)` Wrap a `CheckedObjLongConsumer` in a `ObjLongConsumer`.
`static <T> ObjLongConsumer<T>`	`objLongConsumer(CheckedObjLongConsumer<T> consumer, Consumer<Throwable> handler)` Wrap a `CheckedObjLongConsumer` in a `ObjLongConsumer` with a custom handler for checked exceptions.
`static <T> Predicate<T>`	`predicate(CheckedPredicate<T> predicate)` Wrap a `CheckedPredicate` in a `Predicate`.
`static <T> Predicate<T>`	`predicate(CheckedPredicate<T> function, Consumer<Throwable> handler)` Wrap a `CheckedPredicate` in a `Predicate` with a custom handler for checked exceptions.
`static Runnable`	`runnable(CheckedRunnable runnable)` Wrap a `CheckedRunnable` in a `Runnable`.
`static Runnable`	`runnable(CheckedRunnable runnable, Consumer<Throwable> handler)` Wrap a `CheckedRunnable` in a `Runnable` with a custom handler for checked exceptions.
`static <T> Supplier<T>`	`supplier(CheckedSupplier<T> supplier)` Wrap a `CheckedSupplier` in a `Supplier`.
`static <T> Supplier<T>`	`supplier(CheckedSupplier<T> supplier, Consumer<Throwable> handler)` Wrap a `CheckedSupplier` in a `Supplier` with a custom handler for checked exceptions.
`static <T,U> ToDoubleBiFunction<T,U>`	`toDoubleBiFunction(CheckedToDoubleBiFunction<T,U> function)` Wrap a `CheckedToDoubleBiFunction` in a `ToDoubleBiFunction`.
`static <T,U> ToDoubleBiFunction<T,U>`	`toDoubleBiFunction(CheckedToDoubleBiFunction<T,U> function, Consumer<Throwable> handler)` Wrap a `CheckedToDoubleBiFunction` in a `ToDoubleBiFunction` with a custom handler for checked exceptions.
`static <T> ToDoubleFunction<T>`	`toDoubleFunction(CheckedToDoubleFunction<T> function)` Wrap a `CheckedToDoubleFunction` in a `ToDoubleFunction`.
`static <T> ToDoubleFunction<T>`	`toDoubleFunction(CheckedToDoubleFunction<T> function, Consumer<Throwable> handler)` Wrap a `CheckedToDoubleFunction` in a `ToDoubleFunction` with a custom handler for checked exceptions.
`static <T,U> ToIntBiFunction<T,U>`	`toIntBiFunction(CheckedToIntBiFunction<T,U> function)` Wrap a `CheckedToIntBiFunction` in a `ToIntBiFunction`.
`static <T,U> ToIntBiFunction<T,U>`	`toIntBiFunction(CheckedToIntBiFunction<T,U> function, Consumer<Throwable> handler)` Wrap a `CheckedToIntBiFunction` in a `ToIntBiFunction` with a custom handler for checked exceptions.
`static <T> ToIntFunction<T>`	`toIntFunction(CheckedToIntFunction<T> function)` Wrap a `CheckedToIntFunction` in a `ToIntFunction`.
`static <T> ToIntFunction<T>`	`toIntFunction(CheckedToIntFunction<T> function, Consumer<Throwable> handler)` Wrap a `CheckedToIntFunction` in a `ToIntFunction` with a custom handler for checked exceptions.
`static <T,U> ToLongBiFunction<T,U>`	`toLongBiFunction(CheckedToLongBiFunction<T,U> function)` Wrap a `CheckedToLongBiFunction` in a `ToLongBiFunction`.
`static <T,U> ToLongBiFunction<T,U>`	`toLongBiFunction(CheckedToLongBiFunction<T,U> function, Consumer<Throwable> handler)` Wrap a `CheckedToLongBiFunction` in a `ToLongBiFunction` with a custom handler for checked exceptions.
`static <T> ToLongFunction<T>`	`toLongFunction(CheckedToLongFunction<T> function)` Wrap a `CheckedToLongFunction` in a `ToLongFunction`.
`static <T> ToLongFunction<T>`	`toLongFunction(CheckedToLongFunction<T> function, Consumer<Throwable> handler)` Wrap a `CheckedToLongFunction` in a `ToLongFunction` with a custom handler for checked exceptions.
`static <T> UnaryOperator<T>`	`unaryOperator(CheckedUnaryOperator<T> operator)` Wrap a `CheckedUnaryOperator` in a `UnaryOperator`.
`static <T> UnaryOperator<T>`	`unaryOperator(CheckedUnaryOperator<T> operator, Consumer<Throwable> handler)` Wrap a `CheckedUnaryOperator` in a `UnaryOperator` with a custom handler for checked exceptions.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- THROWABLE_TO_RUNTIME_EXCEPTION
```
public static final Consumer<Throwable> THROWABLE_TO_RUNTIME_EXCEPTION
```
  A Consumer that wraps any Throwable in a RuntimeException.

Method Detail

runnable

public static Runnable runnable(CheckedRunnable runnable)

Wrap a CheckedRunnable in a Runnable.

Example:


 new Thread(Unchecked.runnable(() -> {
     throw new Exception("Cannot run this thread");
 })).start();

runnable

public static Runnable runnable(CheckedRunnable runnable,
                                Consumer<Throwable> handler)

Wrap a CheckedRunnable in a Runnable with a custom handler for checked exceptions.

Example:


 new Thread(Unchecked.runnable(
     () -> {
         throw new Exception("Cannot run this thread");
     },
     e -> {
         throw new IllegalStateException(e);
     }
 )).start();

comparator

public static <T> Comparator<T> comparator(CheckedComparator<T> comparator)

Wrap a CheckedComparator in a Comparator.

comparator

public static <T> Comparator<T> comparator(CheckedComparator<T> comparator,
                                           Consumer<Throwable> handler)

Wrap a CheckedComparator in a Comparator with a custom handler for checked exceptions.

biConsumer

public static <T,U> BiConsumer<T,U> biConsumer(CheckedBiConsumer<T,U> consumer)

Wrap a CheckedBiConsumer in a BiConsumer.

Example:


 map.forEach(Unchecked.biConsumer((k, v) -> {
     if (k == null || v == null)
         throw new Exception("No nulls allowed in map");
 }));

biConsumer

public static <T,U> BiConsumer<T,U> biConsumer(CheckedBiConsumer<T,U> consumer,
                                               Consumer<Throwable> handler)

Wrap a CheckedBiConsumer in a BiConsumer with a custom handler for checked exceptions.

Example:


 map.forEach(Unchecked.biConsumer(
     (k, v) -> {
         if (k == null || v == null)
             throw new Exception("No nulls allowed in map");
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

objIntConsumer

public static <T> ObjIntConsumer<T> objIntConsumer(CheckedObjIntConsumer<T> consumer)

Wrap a CheckedObjIntConsumer in a ObjIntConsumer.

objIntConsumer

public static <T> ObjIntConsumer<T> objIntConsumer(CheckedObjIntConsumer<T> consumer,
                                                   Consumer<Throwable> handler)

Wrap a CheckedObjIntConsumer in a ObjIntConsumer with a custom handler for checked exceptions.

objLongConsumer

public static <T> ObjLongConsumer<T> objLongConsumer(CheckedObjLongConsumer<T> consumer)

Wrap a CheckedObjLongConsumer in a ObjLongConsumer.

objLongConsumer

public static <T> ObjLongConsumer<T> objLongConsumer(CheckedObjLongConsumer<T> consumer,
                                                     Consumer<Throwable> handler)

Wrap a CheckedObjLongConsumer in a ObjLongConsumer with a custom handler for checked exceptions.

objDoubleConsumer

public static <T> ObjDoubleConsumer<T> objDoubleConsumer(CheckedObjDoubleConsumer<T> consumer)

Wrap a CheckedObjDoubleConsumer in a ObjDoubleConsumer.

objDoubleConsumer

public static <T> ObjDoubleConsumer<T> objDoubleConsumer(CheckedObjDoubleConsumer<T> consumer,
                                                         Consumer<Throwable> handler)

Wrap a CheckedObjDoubleConsumer in a ObjDoubleConsumer with a custom handler for checked exceptions.

biFunction

public static <T,U,R> BiFunction<T,U,R> biFunction(CheckedBiFunction<T,U,R> function)

Wrap a CheckedBiFunction in a BiFunction.

Example:


 map.computeIfPresent("key", Unchecked.biFunction((k, v) -> {
     if (k == null || v == null)
         throw new Exception("No nulls allowed in map");

     return 42;
 }));

biFunction

public static <T,U,R> BiFunction<T,U,R> biFunction(CheckedBiFunction<T,U,R> function,
                                                   Consumer<Throwable> handler)

Wrap a CheckedBiFunction in a BiFunction with a custom handler for checked exceptions.

Example:


 map.computeIfPresent("key", Unchecked.biFunction(
     (k, v) -> {
         if (k == null || v == null)
             throw new Exception("No nulls allowed in map");

         return 42;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

toIntBiFunction

public static <T,U> ToIntBiFunction<T,U> toIntBiFunction(CheckedToIntBiFunction<T,U> function)

Wrap a CheckedToIntBiFunction in a ToIntBiFunction.

toIntBiFunction

public static <T,U> ToIntBiFunction<T,U> toIntBiFunction(CheckedToIntBiFunction<T,U> function,
                                                         Consumer<Throwable> handler)

Wrap a CheckedToIntBiFunction in a ToIntBiFunction with a custom handler for checked exceptions.

toLongBiFunction

public static <T,U> ToLongBiFunction<T,U> toLongBiFunction(CheckedToLongBiFunction<T,U> function)

Wrap a CheckedToLongBiFunction in a ToLongBiFunction.

toLongBiFunction

public static <T,U> ToLongBiFunction<T,U> toLongBiFunction(CheckedToLongBiFunction<T,U> function,
                                                           Consumer<Throwable> handler)

Wrap a CheckedToLongBiFunction in a ToLongBiFunction with a custom handler for checked exceptions.

toDoubleBiFunction

public static <T,U> ToDoubleBiFunction<T,U> toDoubleBiFunction(CheckedToDoubleBiFunction<T,U> function)

Wrap a CheckedToDoubleBiFunction in a ToDoubleBiFunction.

toDoubleBiFunction

public static <T,U> ToDoubleBiFunction<T,U> toDoubleBiFunction(CheckedToDoubleBiFunction<T,U> function,
                                                               Consumer<Throwable> handler)

Wrap a CheckedToDoubleBiFunction in a ToDoubleBiFunction with a custom handler for checked exceptions.

biPredicate

public static <T,U> BiPredicate<T,U> biPredicate(CheckedBiPredicate<T,U> predicate)

Wrap a CheckedBiPredicate in a BiPredicate.

biPredicate

public static <T,U> BiPredicate<T,U> biPredicate(CheckedBiPredicate<T,U> predicate,
                                                 Consumer<Throwable> handler)

Wrap a CheckedBiPredicate in a BiPredicate with a custom handler for checked exceptions.

binaryOperator

public static <T> BinaryOperator<T> binaryOperator(CheckedBinaryOperator<T> operator)

Wrap a CheckedBinaryOperator in a BinaryOperator.

Example:


 Stream.of("a", "b", "c").reduce(Unchecked.binaryOperator((s1, s2) -> {
     if (s2.length() > 10)
         throw new Exception("Only short strings allowed");

     return s1 + s2;
 }));

binaryOperator

public static <T> BinaryOperator<T> binaryOperator(CheckedBinaryOperator<T> operator,
                                                   Consumer<Throwable> handler)

Wrap a CheckedBinaryOperator in a BinaryOperator with a custom handler for checked exceptions.

Example:


 Stream.of("a", "b", "c").reduce(Unchecked.binaryOperator(
     (s1, s2) -> {
         if (s2.length() > 10)
             throw new Exception("Only short strings allowed");

         return s1 + s2;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intBinaryOperator

public static IntBinaryOperator intBinaryOperator(CheckedIntBinaryOperator operator)

Wrap a CheckedIntBinaryOperator in a IntBinaryOperator.

Example:


 IntStream.of(1, 2, 3).reduce(Unchecked.intBinaryOperator((i1, i2) -> {
     if (i2 < 0)
         throw new Exception("Only positive numbers allowed");

     return i1 + i2;
 }));

intBinaryOperator

public static IntBinaryOperator intBinaryOperator(CheckedIntBinaryOperator operator,
                                                  Consumer<Throwable> handler)

Wrap a CheckedIntBinaryOperator in a IntBinaryOperator with a custom handler for checked exceptions.

Example:


 IntStream.of(1, 2, 3).reduce(Unchecked.intBinaryOperator(
     (i1, i2) -> {
         if (i2 < 0)
             throw new Exception("Only positive numbers allowed");

         return i1 + i2;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longBinaryOperator

public static LongBinaryOperator longBinaryOperator(CheckedLongBinaryOperator operator)

Wrap a CheckedLongBinaryOperator in a LongBinaryOperator.

Example:


 LongStream.of(1L, 2L, 3L).reduce(Unchecked.longBinaryOperator((l1, l2) -> {
     if (l2 < 0L)
         throw new Exception("Only positive numbers allowed");

     return l1 + l2;
 }));

longBinaryOperator

public static LongBinaryOperator longBinaryOperator(CheckedLongBinaryOperator operator,
                                                    Consumer<Throwable> handler)

Wrap a CheckedLongBinaryOperator in a LongBinaryOperator with a custom handler for checked exceptions.

Example:


 LongStream.of(1L, 2L, 3L).reduce(Unchecked.longBinaryOperator(
     (l1, l2) -> {
         if (l2 < 0L)
             throw new Exception("Only positive numbers allowed");

         return l1 + l2;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doubleBinaryOperator

public static DoubleBinaryOperator doubleBinaryOperator(CheckedDoubleBinaryOperator operator)

Wrap a CheckedDoubleBinaryOperator in a DoubleBinaryOperator.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).reduce(Unchecked.doubleBinaryOperator((d1, d2) -> {
     if (d2 < 0.0)
         throw new Exception("Only positive numbers allowed");

     return d1 + d2;
 }));

doubleBinaryOperator

public static DoubleBinaryOperator doubleBinaryOperator(CheckedDoubleBinaryOperator operator,
                                                        Consumer<Throwable> handler)

Wrap a CheckedDoubleBinaryOperator in a DoubleBinaryOperator with a custom handler for checked exceptions.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).reduce(Unchecked.doubleBinaryOperator(
     (d1, d2) -> {
         if (d2 < 0.0)
             throw new Exception("Only positive numbers allowed");

         return d1 + d2;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

consumer

public static <T> Consumer<T> consumer(CheckedConsumer<T> consumer)

Wrap a CheckedConsumer in a Consumer.

Example:


 Arrays.asList("a", "b").stream().forEach(Unchecked.consumer(s -> {
     if (s.length() > 10)
         throw new Exception("Only short strings allowed");
 }));

consumer

public static <T> Consumer<T> consumer(CheckedConsumer<T> consumer,
                                       Consumer<Throwable> handler)

Wrap a CheckedConsumer in a Consumer with a custom handler for checked exceptions.

Example:


 Arrays.asList("a", "b").stream().forEach(Unchecked.consumer(
     s -> {
         if (s.length() > 10)
             throw new Exception("Only short strings allowed");
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intConsumer

public static IntConsumer intConsumer(CheckedIntConsumer consumer)

Wrap a CheckedIntConsumer in a IntConsumer.

Example:


 Arrays.stream(new int[] { 1, 2 }).forEach(Unchecked.intConsumer(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");
 }));

intConsumer

public static IntConsumer intConsumer(CheckedIntConsumer consumer,
                                      Consumer<Throwable> handler)

Wrap a CheckedIntConsumer in a IntConsumer with a custom handler for checked exceptions.

Example:


 Arrays.stream(new int[] { 1, 2 }).forEach(Unchecked.intConsumer(
     i -> {
         if (i < 0)
             throw new Exception("Only positive numbers allowed");
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longConsumer

public static LongConsumer longConsumer(CheckedLongConsumer consumer)

Wrap a CheckedLongConsumer in a LongConsumer.

Example:


 Arrays.stream(new long[] { 1L, 2L }).forEach(Unchecked.longConsumer(l -> {
     if (l < 0)
         throw new Exception("Only positive numbers allowed");
 }));

longConsumer

public static LongConsumer longConsumer(CheckedLongConsumer consumer,
                                        Consumer<Throwable> handler)

Wrap a CheckedLongConsumer in a LongConsumer with a custom handler for checked exceptions.

Example:


 Arrays.stream(new long[] { 1L, 2L }).forEach(Unchecked.longConsumer(
     l -> {
         if (l < 0)
             throw new Exception("Only positive numbers allowed");
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doubleConsumer

public static DoubleConsumer doubleConsumer(CheckedDoubleConsumer consumer)

Wrap a CheckedDoubleConsumer in a DoubleConsumer.

Example:


 Arrays.stream(new double[] { 1.0, 2.0 }).forEach(Unchecked.doubleConsumer(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");
 }));

doubleConsumer

public static DoubleConsumer doubleConsumer(CheckedDoubleConsumer consumer,
                                            Consumer<Throwable> handler)

Wrap a CheckedDoubleConsumer in a DoubleConsumer with a custom handler for checked exceptions.

Example:


 Arrays.stream(new double[] { 1.0, 2.0 }).forEach(Unchecked.doubleConsumer(
     d -> {
         if (d < 0.0)
             throw new Exception("Only positive numbers allowed");
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

function

public static <T,R> Function<T,R> function(CheckedFunction<T,R> function)

Wrap a CheckedFunction in a Function.

Example:


 map.computeIfAbsent("key", Unchecked.function(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42;
 }));

function

public static <T,R> Function<T,R> function(CheckedFunction<T,R> function,
                                           Consumer<Throwable> handler)

Wrap a CheckedFunction in a Function with a custom handler for checked exceptions.

Example:


 map.forEach(Unchecked.function(
     k -> {
         if (k.length() > 10)
             throw new Exception("Only short strings allowed");

         return 42;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

toIntFunction

public static <T> ToIntFunction<T> toIntFunction(CheckedToIntFunction<T> function)

Wrap a CheckedToIntFunction in a ToIntFunction.

Example:


 map.computeIfAbsent("key", Unchecked.toIntFunction(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42;
 }));

toIntFunction

public static <T> ToIntFunction<T> toIntFunction(CheckedToIntFunction<T> function,
                                                 Consumer<Throwable> handler)

Wrap a CheckedToIntFunction in a ToIntFunction with a custom handler for checked exceptions.

Example:


 map.forEach(Unchecked.toIntFunction(
     k -> {
         if (k.length() > 10)
             throw new Exception("Only short strings allowed");

         return 42;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

toLongFunction

public static <T> ToLongFunction<T> toLongFunction(CheckedToLongFunction<T> function)

Wrap a CheckedToLongFunction in a ToLongFunction.

Example:


 map.computeIfAbsent("key", Unchecked.toLongFunction(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42L;
 }));

toLongFunction

public static <T> ToLongFunction<T> toLongFunction(CheckedToLongFunction<T> function,
                                                   Consumer<Throwable> handler)

Wrap a CheckedToLongFunction in a ToLongFunction with a custom handler for checked exceptions.

Example:


 map.forEach(Unchecked.toLongFunction(
     k -> {
         if (k.length() > 10)
             throw new Exception("Only short strings allowed");

         return 42L;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

toDoubleFunction

public static <T> ToDoubleFunction<T> toDoubleFunction(CheckedToDoubleFunction<T> function)

Wrap a CheckedToDoubleFunction in a ToDoubleFunction.

Example:


 map.computeIfAbsent("key", Unchecked.toDoubleFunction(k -> {
     if (k.length() > 10)
         throw new Exception("Only short strings allowed");

     return 42.0;
 }));

toDoubleFunction

public static <T> ToDoubleFunction<T> toDoubleFunction(CheckedToDoubleFunction<T> function,
                                                       Consumer<Throwable> handler)

Wrap a CheckedToDoubleFunction in a ToDoubleFunction with a custom handler for checked exceptions.

Example:


 map.forEach(Unchecked.toDoubleFunction(
     k -> {
         if (k.length() > 10)
             throw new Exception("Only short strings allowed");

         return 42.0;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intFunction

public static <R> IntFunction<R> intFunction(CheckedIntFunction<R> function)

Wrap a CheckedIntFunction in a IntFunction.

Example:


 IntStream.of(1, 2, 3).mapToObj(Unchecked.intFunction(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return "" + i;
 });

intFunction

public static <R> IntFunction<R> intFunction(CheckedIntFunction<R> function,
                                             Consumer<Throwable> handler)

Wrap a CheckedIntFunction in a IntFunction with a custom handler for checked exceptions.

Example:


 IntStream.of(1, 2, 3).mapToObj(Unchecked.intFunction(
     i -> {
         if (i < 0)
             throw new Exception("Only positive numbers allowed");

         return "" + i;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intToLongFunction

public static IntToLongFunction intToLongFunction(CheckedIntToLongFunction function)

Wrap a CheckedIntToLongFunction in a IntToLongFunction.

Example:


 IntStream.of(1, 2, 3).mapToLong(Unchecked.intToLongFunction(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return (long) i;
 });

intToLongFunction

public static IntToLongFunction intToLongFunction(CheckedIntToLongFunction function,
                                                  Consumer<Throwable> handler)

Wrap a CheckedIntToLongFunction in a IntToLongFunction with a custom handler for checked exceptions.

Example:


 IntStream.of(1, 2, 3).mapToLong(Unchecked.intToLongFunction(
     i -> {
         if (i < 0)
             throw new Exception("Only positive numbers allowed");

         return (long) i;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intToDoubleFunction

public static IntToDoubleFunction intToDoubleFunction(CheckedIntToDoubleFunction function)

Wrap a CheckedIntToDoubleFunction in a IntToDoubleFunction.

Example:


 IntStream.of(1, 2, 3).mapToDouble(Unchecked.intToDoubleFunction(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return (double) i;
 });

intToDoubleFunction

public static IntToDoubleFunction intToDoubleFunction(CheckedIntToDoubleFunction function,
                                                      Consumer<Throwable> handler)

Wrap a CheckedIntToDoubleFunction in a IntToDoubleFunction with a custom handler for checked exceptions.

Example:


 IntStream.of(1, 2, 3).mapToDouble(Unchecked.intToDoubleFunction(
     i -> {
         if (i < 0)
             throw new Exception("Only positive numbers allowed");

         return (double) i;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longFunction

public static <R> LongFunction<R> longFunction(CheckedLongFunction<R> function)

Wrap a CheckedLongFunction in a LongFunction.

Example:


 LongStream.of(1L, 2L, 3L).mapToObj(Unchecked.longFunction(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return "" + l;
 });

longFunction

public static <R> LongFunction<R> longFunction(CheckedLongFunction<R> function,
                                               Consumer<Throwable> handler)

Wrap a CheckedLongFunction in a LongFunction with a custom handler for checked exceptions.

Example:


 LongStream.of(1L, 2L, 3L).mapToObj(Unchecked.longFunction(
     l -> {
         if (l < 0L)
             throw new Exception("Only positive numbers allowed");

         return "" + l;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longToIntFunction

public static LongToIntFunction longToIntFunction(CheckedLongToIntFunction function)

Wrap a CheckedLongToIntFunction in a LongToIntFunction.

Example:


 LongStream.of(1L, 2L, 3L).mapToInt(Unchecked.longToIntFunction(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return (int) l;
 });

longToIntFunction

public static LongToIntFunction longToIntFunction(CheckedLongToIntFunction function,
                                                  Consumer<Throwable> handler)

Wrap a CheckedLongToIntFunction in a LongToIntFunction with a custom handler for checked exceptions.

Example:


 LongStream.of(1L, 2L, 3L).mapToInt(Unchecked.longToIntFunction(
     l -> {
         if (l < 0L)
             throw new Exception("Only positive numbers allowed");

         return (int) l;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longToDoubleFunction

public static LongToDoubleFunction longToDoubleFunction(CheckedLongToDoubleFunction function)

Wrap a CheckedLongToDoubleFunction in a LongToDoubleFunction.

Example:


 LongStream.of(1L, 2L, 3L).mapToInt(Unchecked.longToDoubleFunction(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return (double) l;
 });

longToDoubleFunction

public static LongToDoubleFunction longToDoubleFunction(CheckedLongToDoubleFunction function,
                                                        Consumer<Throwable> handler)

Wrap a CheckedLongToDoubleFunction in a LongToDoubleFunction with a custom handler for checked exceptions.

Example:


 LongStream.of(1L, 2L, 3L).mapToInt(Unchecked.longToDoubleFunction(
     l -> {
         if (l < 0L)
             throw new Exception("Only positive numbers allowed");

         return (double) l;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doubleFunction

public static <R> DoubleFunction<R> doubleFunction(CheckedDoubleFunction<R> function)

Wrap a CheckedDoubleFunction in a DoubleFunction.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).mapToObj(Unchecked.doubleFunction(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return "" + d;
 });

doubleFunction

public static <R> DoubleFunction<R> doubleFunction(CheckedDoubleFunction<R> function,
                                                   Consumer<Throwable> handler)

Wrap a CheckedDoubleFunction in a DoubleFunction with a custom handler for checked exceptions.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).mapToObj(Unchecked.doubleFunction(
     d -> {
         if (d < 0.0)
             throw new Exception("Only positive numbers allowed");

         return "" + d;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doubleToIntFunction

public static DoubleToIntFunction doubleToIntFunction(CheckedDoubleToIntFunction function)

Wrap a CheckedDoubleToIntFunction in a DoubleToIntFunction.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).mapToInt(Unchecked.doubleToIntFunction(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return (int) d;
 });

doubleToIntFunction

public static DoubleToIntFunction doubleToIntFunction(CheckedDoubleToIntFunction function,
                                                      Consumer<Throwable> handler)

Wrap a CheckedDoubleToIntFunction in a DoubleToIntFunction with a custom handler for checked exceptions.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).mapToInt(Unchecked.doubleToIntFunction(
     d -> {
         if (d < 0.0)
             throw new Exception("Only positive numbers allowed");

         return (int) d;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doubleToLongFunction

public static DoubleToLongFunction doubleToLongFunction(CheckedDoubleToLongFunction function)

Wrap a CheckedDoubleToLongFunction in a DoubleToLongFunction.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).mapToLong(Unchecked.doubleToLongFunction(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return (long) d;
 });

doubleToLongFunction

public static DoubleToLongFunction doubleToLongFunction(CheckedDoubleToLongFunction function,
                                                        Consumer<Throwable> handler)

Wrap a CheckedDoubleToLongFunction in a DoubleToLongFunction with a custom handler for checked exceptions.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).mapToLong(Unchecked.doubleToLongFunction(
     d -> {
         if (d < 0.0)
             throw new Exception("Only positive numbers allowed");

         return (long) d;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

predicate

public static <T> Predicate<T> predicate(CheckedPredicate<T> predicate)

Wrap a CheckedPredicate in a Predicate.

Example:


 Stream.of("a", "b", "c").filter(Unchecked.predicate(s -> {
     if (s.length() > 10)
         throw new Exception("Only short strings allowed");

     return true;
 }));

predicate

public static <T> Predicate<T> predicate(CheckedPredicate<T> function,
                                         Consumer<Throwable> handler)

Wrap a CheckedPredicate in a Predicate with a custom handler for checked exceptions.

Example:


 Stream.of("a", "b", "c").filter(Unchecked.predicate(
     s -> {
         if (s.length() > 10)
             throw new Exception("Only short strings allowed");

         return true;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intPredicate

public static IntPredicate intPredicate(CheckedIntPredicate predicate)

Wrap a CheckedPredicate in a IntPredicate.

Example:


 IntStream.of(1, 2, 3).filter(Unchecked.intPredicate(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return true;
 }));

intPredicate

public static IntPredicate intPredicate(CheckedIntPredicate function,
                                        Consumer<Throwable> handler)

Wrap a CheckedPredicate in a IntPredicate with a custom handler for checked exceptions.

Example:


 IntStream.of(1, 2, 3).filter(Unchecked.intPredicate(
     i -> {
         if (i < 0)
             throw new Exception("Only positive numbers allowed");

         return true;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longPredicate

public static LongPredicate longPredicate(CheckedLongPredicate predicate)

Wrap a CheckedLongPredicate in a LongPredicate.

Example:


 LongStream.of(1L, 2L, 3L).filter(Unchecked.longPredicate(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return true;
 }));

longPredicate

public static LongPredicate longPredicate(CheckedLongPredicate function,
                                          Consumer<Throwable> handler)

Wrap a CheckedLongPredicate in a LongPredicate with a custom handler for checked exceptions.

Example:


 LongStream.of(1L, 2L, 3L).filter(Unchecked.longPredicate(
     l -> {
         if (l < 0L)
             throw new Exception("Only positive numbers allowed");

         return true;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doublePredicate

public static DoublePredicate doublePredicate(CheckedDoublePredicate predicate)

Wrap a CheckedDoublePredicate in a DoublePredicate.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).filter(Unchecked.doublePredicate(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return true;
 }));

doublePredicate

public static DoublePredicate doublePredicate(CheckedDoublePredicate function,
                                              Consumer<Throwable> handler)

Wrap a CheckedDoublePredicate in a DoublePredicate with a custom handler for checked exceptions.

Example:


 DoubleStream.of(1.0, 2.0, 3.0).filter(Unchecked.doublePredicate(
     d -> {
         if (d < 0.0)
             throw new Exception("Only positive numbers allowed");

         return true;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

supplier

public static <T> Supplier<T> supplier(CheckedSupplier<T> supplier)

Wrap a CheckedSupplier in a Supplier.

Example:


 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.supplier(() -> rs.getObject(1)));

supplier

public static <T> Supplier<T> supplier(CheckedSupplier<T> supplier,
                                       Consumer<Throwable> handler)

Wrap a CheckedSupplier in a Supplier with a custom handler for checked exceptions.

Example:


 ResultSet rs = statement.executeQuery();

 Stream.generate(Unchecked.supplier(
     () -> rs.getObject(1),
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intSupplier

public static IntSupplier intSupplier(CheckedIntSupplier supplier)

Wrap a CheckedIntSupplier in a IntSupplier.

Example:


 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.intSupplier(() -> rs.getInt(1)));

intSupplier

public static IntSupplier intSupplier(CheckedIntSupplier supplier,
                                      Consumer<Throwable> handler)

Wrap a CheckedIntSupplier in a IntSupplier with a custom handler for checked exceptions.

Example:


 ResultSet rs = statement.executeQuery();

 Stream.generate(Unchecked.intSupplier(
     () -> rs.getInt(1),
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longSupplier

public static LongSupplier longSupplier(CheckedLongSupplier supplier)

Wrap a CheckedLongSupplier in a LongSupplier.

Example:


 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.longSupplier(() -> rs.getLong(1)));

longSupplier

public static LongSupplier longSupplier(CheckedLongSupplier supplier,
                                        Consumer<Throwable> handler)

Wrap a CheckedLongSupplier in a LongSupplier with a custom handler for checked exceptions.

Example:


 ResultSet rs = statement.executeQuery();

 Stream.generate(Unchecked.longSupplier(
     () -> rs.getLong(1),
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doubleSupplier

public static DoubleSupplier doubleSupplier(CheckedDoubleSupplier supplier)

Wrap a CheckedDoubleSupplier in a DoubleSupplier.

Example:


 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.doubleSupplier(() -> rs.getDouble(1)));

doubleSupplier

public static DoubleSupplier doubleSupplier(CheckedDoubleSupplier supplier,
                                            Consumer<Throwable> handler)

Wrap a CheckedDoubleSupplier in a DoubleSupplier with a custom handler for checked exceptions.

Example:


 ResultSet rs = statement.executeQuery();

 Stream.generate(Unchecked.doubleSupplier(
     () -> rs.getDouble(1),
     e -> {
         throw new IllegalStateException(e);
     }
 ));

booleanSupplier

public static BooleanSupplier booleanSupplier(CheckedBooleanSupplier supplier)

Wrap a CheckedBooleanSupplier in a BooleanSupplier.

Example:


 ResultSet rs = statement.executeQuery();
 Stream.generate(Unchecked.booleanSupplier(() -> rs.getBoolean(1)));

booleanSupplier

public static BooleanSupplier booleanSupplier(CheckedBooleanSupplier supplier,
                                              Consumer<Throwable> handler)

Wrap a CheckedBooleanSupplier in a BooleanSupplier with a custom handler for checked exceptions.

Example:


 ResultSet rs = statement.executeQuery();

 Stream.generate(Unchecked.booleanSupplier(
     () -> rs.getBoolean(1),
     e -> {
         throw new IllegalStateException(e);
     }
 ));

unaryOperator

public static <T> UnaryOperator<T> unaryOperator(CheckedUnaryOperator<T> operator)

Wrap a CheckedUnaryOperator in a UnaryOperator.

Example:


 Stream.of("a", "b", "c").map(Unchecked.unaryOperator(s -> {
     if (s.length() > 10)
         throw new Exception("Only short strings allowed");

     return s;
 }));

unaryOperator

public static <T> UnaryOperator<T> unaryOperator(CheckedUnaryOperator<T> operator,
                                                 Consumer<Throwable> handler)

Wrap a CheckedUnaryOperator in a UnaryOperator with a custom handler for checked exceptions.

Example:


 Stream.of("a", "b", "c").map(Unchecked.unaryOperator(
     s -> {
         if (s.length() > 10)
             throw new Exception("Only short strings allowed");

         return s;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

intUnaryOperator

public static IntUnaryOperator intUnaryOperator(CheckedIntUnaryOperator operator)

Wrap a CheckedIntUnaryOperator in a IntUnaryOperator.

Example:


 IntStream.of(1, 2, 3).map(Unchecked.intUnaryOperator(i -> {
     if (i < 0)
         throw new Exception("Only positive numbers allowed");

     return i;
 }));

intUnaryOperator

public static IntUnaryOperator intUnaryOperator(CheckedIntUnaryOperator operator,
                                                Consumer<Throwable> handler)

Wrap a CheckedIntUnaryOperator in a IntUnaryOperator with a custom handler for checked exceptions.

Example:


 IntStream.of(1, 2, 3).map(Unchecked.intUnaryOperator(
     i -> {
         if (i < 0)
             throw new Exception("Only positive numbers allowed");

         return i;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

longUnaryOperator

public static LongUnaryOperator longUnaryOperator(CheckedLongUnaryOperator operator)

Wrap a CheckedLongUnaryOperator in a LongUnaryOperator.

Example:


 LongStream.of(1L, 2L, 3L).map(Unchecked.longUnaryOperator(l -> {
     if (l < 0L)
         throw new Exception("Only positive numbers allowed");

     return l;
 }));

longUnaryOperator

public static LongUnaryOperator longUnaryOperator(CheckedLongUnaryOperator operator,
                                                  Consumer<Throwable> handler)

Wrap a CheckedLongUnaryOperator in a LongUnaryOperator with a custom handler for checked exceptions.

Example:


 LongStream.of(1L, 2L, 3L).map(Unchecked.longUnaryOperator(
     l -> {
         if (l < 0L)
             throw new Exception("Only positive numbers allowed");

         return l;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

doubleUnaryOperator

public static DoubleUnaryOperator doubleUnaryOperator(CheckedDoubleUnaryOperator operator)

Wrap a CheckedDoubleUnaryOperator in a DoubleUnaryOperator.

Example:


 LongStream.of(1.0, 2.0, 3.0).map(Unchecked.doubleUnaryOperator(d -> {
     if (d < 0.0)
         throw new Exception("Only positive numbers allowed");

     return d;
 }));

doubleUnaryOperator

public static DoubleUnaryOperator doubleUnaryOperator(CheckedDoubleUnaryOperator operator,
                                                      Consumer<Throwable> handler)

Wrap a CheckedDoubleUnaryOperator in a DoubleUnaryOperator with a custom handler for checked exceptions.

Example:


 LongStream.of(1.0, 2.0, 3.0).map(Unchecked.doubleUnaryOperator(
     d -> {
         if (d < 0.0)
             throw new Exception("Only positive numbers allowed");

         return d;
     },
     e -> {
         throw new IllegalStateException(e);
     }
 ));

Class Unchecked

Field Summary

Fields

Method Summary

Methods

Methods inherited from class java.lang.Object

Field Detail

THROWABLE_TO_RUNTIME_EXCEPTION

Method Detail

runnable

runnable

comparator

comparator

biConsumer

biConsumer

objIntConsumer

objIntConsumer

objLongConsumer

objLongConsumer

objDoubleConsumer

objDoubleConsumer

biFunction

biFunction

toIntBiFunction

toIntBiFunction

toLongBiFunction

toLongBiFunction

toDoubleBiFunction

toDoubleBiFunction

biPredicate

biPredicate

binaryOperator

binaryOperator

intBinaryOperator

intBinaryOperator

longBinaryOperator

longBinaryOperator

doubleBinaryOperator

doubleBinaryOperator

consumer

consumer

intConsumer

intConsumer

longConsumer

longConsumer

doubleConsumer

doubleConsumer

function

function

toIntFunction

toIntFunction

toLongFunction

toLongFunction

toDoubleFunction

toDoubleFunction

intFunction

intFunction

intToLongFunction

intToLongFunction

intToDoubleFunction

intToDoubleFunction

longFunction

longFunction

longToIntFunction

longToIntFunction

longToDoubleFunction

longToDoubleFunction

doubleFunction

doubleFunction

doubleToIntFunction

doubleToIntFunction

doubleToLongFunction

doubleToLongFunction

predicate

predicate

intPredicate

intPredicate

longPredicate

longPredicate

doublePredicate