Sneaky (jOOL 0.9.14 API)

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

```
public final class Sneaky
extends Object
```
Improved interoperability between checked exceptions and Java 8.
Similar to Unchecked, except that Unchecked.RETHROW_ALL is used as the default way to re-throw checked exceptions.

Author:

Lukas Eder

Method Summary

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

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

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

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

comparator

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

Wrap a CheckedComparator in a Comparator.

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

objIntConsumer

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

Wrap a CheckedObjIntConsumer in a ObjIntConsumer.

objLongConsumer

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

Wrap a CheckedObjLongConsumer in a ObjLongConsumer.

objDoubleConsumer

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

Wrap a CheckedObjDoubleConsumer in a ObjDoubleConsumer.

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

toIntBiFunction

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

Wrap a CheckedToIntBiFunction in a ToIntBiFunction.

toLongBiFunction

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

Wrap a CheckedToLongBiFunction in a ToLongBiFunction.

toDoubleBiFunction

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

Wrap a CheckedToDoubleBiFunction in a ToDoubleBiFunction.

biPredicate

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

Wrap a CheckedBiPredicate in a BiPredicate.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Class Sneaky

Method Summary

Methods inherited from class java.lang.Object

Method Detail

throwChecked

runnable

callable

comparator

biConsumer

objIntConsumer

objLongConsumer

objDoubleConsumer

biFunction

toIntBiFunction

toLongBiFunction

toDoubleBiFunction

biPredicate

binaryOperator

intBinaryOperator

longBinaryOperator

doubleBinaryOperator

consumer

intConsumer

longConsumer

doubleConsumer

function

toIntFunction

toLongFunction

toDoubleFunction

intFunction

intToLongFunction

intToDoubleFunction

longFunction

longToIntFunction

longToDoubleFunction

doubleFunction

doubleToIntFunction

doubleToLongFunction

predicate

intPredicate

longPredicate

doublePredicate

supplier

intSupplier

longSupplier

doubleSupplier

booleanSupplier

unaryOperator

intUnaryOperator

longUnaryOperator

doubleUnaryOperator