Class Sneaky


  • public final class Sneaky
    extends java.lang.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.

    • Constructor Detail

      • Sneaky

        private Sneaky()
        No instances
    • Method Detail

      • throwChecked

        public static void throwChecked​(java.lang.Throwable t)
        "sneaky-throw" a checked exception or throwable.
      • runnable

        public static java.lang.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> java.util.concurrent.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();
         
      • biConsumer

        public static <T,​U> java.util.function.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");
         }));
         
      • biFunction

        public static <T,​U,​R> java.util.function.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;
         }));
         
      • binaryOperator

        public static <T> java.util.function.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 java.util.function.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 java.util.function.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 java.util.function.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> java.util.function.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 java.util.function.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 java.util.function.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 java.util.function.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> java.util.function.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> java.util.function.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> java.util.function.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> java.util.function.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> java.util.function.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 java.util.function.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 java.util.function.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> java.util.function.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 java.util.function.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 java.util.function.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> java.util.function.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 java.util.function.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 java.util.function.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> java.util.function.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 java.util.function.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 java.util.function.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 java.util.function.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> java.util.function.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 java.util.function.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 java.util.function.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 java.util.function.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 java.util.function.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> java.util.function.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 java.util.function.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 java.util.function.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 java.util.function.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;
         }));