Package org.jooq.lambda

Class 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.

Author:

Lukas Eder

Field Summary

Fields

Modifier and Type	Field	Description
static Consumer<Throwable>	RETHROW_ALL	A Consumer that rethrows all exceptions, including checked exceptions.
static Consumer<Throwable>	THROWABLE_TO_RUNTIME_EXCEPTION	A Consumer that wraps any Throwable in a RuntimeException.

Method Summary

Modifier and Type	Method	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> Callable<T>	callable(CheckedCallable<T> callable)	Wrap a CheckedCallable in a Callable.
static <T> Callable<T>	callable(CheckedCallable<T> callable, Consumer<Throwable> handler)	Wrap a CheckedCallable in a Callable 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 void	throwChecked(Throwable t)	"sneaky-throw" a checked exception or throwable.
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.

RETHROW_ALL

public static final Consumer<Throwable> RETHROW_ALL

A Consumer that rethrows all exceptions, including checked exceptions.

Method Detail

throwChecked

public static void throwChecked(Throwable t)

"sneaky-throw" a checked exception or throwable.

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();
 

callable

public static <T> Callable<T> callable(CheckedCallable<T> callable)

Wrap a CheckedCallable in a Callable.

Example:

 Executors.newFixedThreadPool(1).submit(Unchecked.callable(() -> {
     throw new Exception("Cannot execute this task");
 })).get();
 

callable

public static <T> Callable<T> callable(CheckedCallable<T> callable,
                                       Consumer<Throwable> handler)

Wrap a CheckedCallable in a Callable with a custom handler for checked exceptions.

Example:

 Executors.newFixedThreadPool(1).submit(Unchecked.callable(
     () -> {
         throw new Exception("Cannot execute this task");
     },
     e -> {
         throw new IllegalStateException(e);
     }
 )).get();
 

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);
     }
 ));