How can I throw CHECKED exceptions from inside Java 8 streams

Question

How can I throw CHECKED exceptions from inside Java 8 streams lambdas   In other words  I want to make code like this compile   public List lt Class gt  getClasses   throws ClassNotFoundException             List lt Class gt  classes            Stream of  java lang Object    java lang Integer    java lang String                  map className - gt  Class forName className                  collect Collectors toList                           return classes          This code does not compile  since the Class forName   method above throws ClassNotFoundException  which is checked   Please note I do NOT want to wrap the checked exception inside a runtime exception and throw the wrapped unchecked exception instead  I want to throw the checked exception itself  and without adding ugly try catches to the stream

User · Answer

Probably  a better and more functional way is to wrap exceptions and propagate them further in the stream  Take a look at the Try type of Vavr for example   Example   interface CheckedFunction lt I  O gt        O apply I i  throws Exception     static  lt I  O gt  Function lt I  O gt  unchecked CheckedFunction lt I  O gt  f        return i - gt            try               return f apply i             catch Exception ex                 throw new RuntimeException ex                      fileNamesToRead map unchecked file - gt  Files readAllLines file      OR   SuppressWarnings  unchecked   private static  lt T  E extends Exception gt  T throwUnchecked Exception e  throws E       throw  E  e     static  lt I  O gt  Function lt I  O gt  unchecked CheckedFunction lt I  O gt  f        return arg - gt            try               return f apply arg             catch Exception ex                return throwUnchecked ex                        2nd implementation avoids wrapping the exception in a RuntimeException  throwUnchecked works because almost always all generic exceptions are treated as unchecked in java

User · Answer

If you use Spring Framework you can use ReflectionUtils rethrowRuntimeException ex  described here https   docs spring io spring docs 5 2 8 RELEASE javadoc-api org springframework util ReflectionUtils html rethrowRuntimeException-java lang Throwable- The beauty of this util method is that it re-throws exactly same exception but of Runtime type  so your catch block that expects exception of checked type will still catch it as intended

User · Answer

I think this approach is the right one   public List lt Class gt  getClasses   throws ClassNotFoundException       List lt Class gt  classes      try           classes   Stream of  java lang Object    java lang Integer    java lang String   map className - gt                try                   return Class forName className                 catch  ClassNotFoundException e                    throw new UndeclaredThrowableException e                            collect Collectors toList           catch  UndeclaredThrowableException e            if  e getCause   instanceof ClassNotFoundException                throw  ClassNotFoundException  e getCause              else                  this should never happen             throw new IllegalStateException e getMessage    e                       return classes      Wrapping the checked exception inside the Callable in a UndeclaredThrowableException  that   s the use case for this exception  and unwrapping it outside   Yes  I find it ugly  and I would advise against using lambdas in this case and just fall back to a good old loop  unless you are working with a parallel stream and paralellization brings an objective benefit that justifies the unreadability of the code   As many others have pointed out  there are solutions to this situation  and I hope one of them will make it into a future version of Java

User · Answer

Just use any one of NoException  my project   jOO  s Unchecked  throwing-lambdas  Throwable interfaces  or Faux Pas      NoException stream map Exceptions sneak   function Class  forName        jOO  stream map Unchecked function Class  forName        throwing-lambdas stream map Throwing function Class  forName  sneakyThrow         Throwable interfaces stream map FunctionWithThrowable aFunctionThatUnsafelyThrowsUnchecked Class  forName        Faux Pas stream map FauxPas throwingFunction Class  forName

User · Answer

Here is a different view or solution for the original problem  Here I show that we have an option to write a code that will process only a valid subset of values with an option to detect and handle caseses when the exception was thrown         Test     public void getClasses              String   classNames     java lang Object    java lang Integer    java lang Foo            List lt Class gt  classes                   Stream of classNames                           map className - gt                                try                                   return Class forName className                                 catch  ClassNotFoundException e                                       log the error                                 return null                                                                                    filter c - gt  c    null                           collect Collectors toList              if  classes size      classNames length                   add your error handling here if needed or process only the resulting list             System out println  Did not process all class names                       classes forEach System out  println

User · Answer

You cannot   However  you may want to have a look at one of my projects which allows you to more easily manipulate such  throwing lambdas    In your case  you would be able to do that   import static com github fge lambdas functions Functions wrap   final ThrowingFunction lt String  Class lt   gt  gt  f   wrap Class  forName    List lt Class gt  classes       Stream of  java lang Object    java lang Integer    java lang String              map f orThrow MyException class              collect Collectors toList       and catch MyException   That is one example  Another example is that you could  orReturn   some default value   Note that this is STILL a work in progress  more is to come  Better names  more features etc

User · Answer

You can also write a wrapper method to wrap unchecked exceptions  and even enhance wrapper with additional parameter representing another functional interface  with the same return type R    In this case you can pass a function that would be executed and returned in case of exceptions  See example below   private void run         List lt String gt  list   Stream of 1  2  3  4  map wrapper i - gt              String valueOf   i   0   i - gt  String valueOf   i    collect Collectors toList         System out println list toString        private  lt T  R  E extends Exception gt  Function lt T  R gt  wrapper ThrowingFunction lt T  R  E gt  function   Function lt T  R gt  onException        return i - gt            try               return function apply i             catch  ArithmeticException e                System out println  Exception      i               return onException apply i             catch  Exception e                System out println  Other      i               return onException apply i                        FunctionalInterface interface ThrowingFunction lt T  R  E extends Exception gt        R apply T t  throws E

User · Answer

This answer is similar to 17 but avoiding wrapper exception definition   List test   new ArrayList            try               test forEach obj - gt                       let say some functionality throws an exception                 try                       throw new IOException  test                                      catch Exception e                        throw new RuntimeException e                                                       catch  RuntimeException re                if re getCause   instanceof IOException                      do your logic for catching checked                           else                  throw re     it might be that there is real runtime exception

User · Answer

The simple answer to your question is  You can t  at least not directly  And it s not your fault  Oracle messed it up  They cling on the concept of checked exceptions  but inconsistently forgot to take care of checked exceptions when designing the functional interfaces  streams  lambda etc  That s all grist to the mill of experts like Robert C  Martin who call checked exceptions a failed experiment   In my opinion  this is a huge bug in the API and a minor bug in the language specification   The bug in the API is that it provides no facility for forwarding checked exceptions where this actually would make an awful lot of sense for functional programming  As I will demonstrate below  such a facility would ve been easily possible   The bug in the language specification is that it does not allow a type parameter to infer a list of types instead of a single type as long as the type parameter is only used in situations where a list of types is permissable  throws clause    Our expectation as Java programmers is that the following code should compile   import java util ArrayList  import java util List  import java util stream Stream   public class CheckedStream          List variant to demonstrate what we actually had before refactoring      public List lt Class gt  getClasses final List lt String gt  names  throws ClassNotFoundException           final List lt Class gt  classes   new ArrayList lt  gt             for  final String name   names              classes add Class forName name            return classes                The Stream function which we want to compile      public Stream lt Class gt  getClasses final Stream lt String gt  names  throws ClassNotFoundException           return names map Class  forName             However  it gives   cher armor1   playground Java checkedStream  javac CheckedStream java  CheckedStream java 13  error  incompatible thrown types ClassNotFoundException in method reference         return names map Class  forName                              1 error   The way in which the functional interfaces are defined currently prevents the Compiler from forwarding the exception - there is no declaration which would tell Stream map   that if Function apply   throws E  Stream map   throws E as well   What s missing is a declaration of a type parameter for passing through checked exceptions  The following code shows how such a pass-through type parameter actually could have been declared with the current syntax  Except for the special case in the marked line  which is a limit discussed below  this code compiles and behaves as expected   import java io IOException  interface Function lt T  R  E extends Throwable gt           Declare you throw E  whatever that is      R apply T t  throws E        interface Stream lt T gt           Pass through E  whatever mapper defined for E       lt R  E extends Throwable gt  Stream lt R gt  map Function lt   super T    extends R  E gt  mapper  throws E        class Main       public static void main final String    args  throws ClassNotFoundException           final Stream lt String gt  s   null              Works  E is ClassNotFoundException          s map Class  forName               Works  E is RuntimeException  probably           s map Main  convertClass               Works  E is ClassNotFoundException          s map Main  throwSome               Doesn t work  E is Exception          s map Main  throwSomeMore       error  unreported exception Exception  must be caught or declared to be thrown               public static Class convertClass final String s            return Main class                static class FooException extends ClassNotFoundException         static class BarException extends ClassNotFoundException         public static Class throwSome final String s  throws FooException  BarException           throw new FooException                  public static Class throwSomeMore final String s  throws ClassNotFoundException  IOException            throw new FooException                    In the case of throwSomeMore we would like to see IOException being missed  but it actually misses Exception   This is not perfect because type inference seems to be looking for a single type  even in the case of exceptions  Because the type inference needs a single type  E needs to resolve to a common super of ClassNotFoundException and IOException  which is Exception   A tweak to the definition of type inference is needed so that the compiler would look for multiple types if the type parameter is used where a list of types is permissible  throws clause   Then the exception type reported by the compiler would be as specific as the original throws declaration of the checked exceptions of the referenced method  not a single catch-all super type   The bad news is that this means that Oracle messed it up  Certainly they won t break user-land code  but introducing exception type parameters to the existing functional interfaces would break compilation of all user-land code that uses these interfaces explicitly  They ll have to invent some new syntax sugar to fix this   The even worse news is that this topic was already discussed by Brian Goetz in 2010 https   blogs oracle com briangoetz entry exception transparency in java  new link  http   mail openjdk java net pipermail lambda-dev 2010-June 001484 html  but I m informed that this investigation ultimately did not pan out  and that there is no current work at Oracle that I know of to mitigate the interactions between checked exceptions and lambdas

User · Answer

You can t do this safely   You can cheat  but then your program is broken and this will inevitably come back to bite someone  it should be you  but often our cheating blows up on someone else      Here s a slightly safer way to do it  but I still don t recommend this    class WrappedException extends RuntimeException       Throwable cause       WrappedException Throwable cause    this cause   cause       static WrappedException throwWrapped Throwable t        throw new WrappedException t      try      source stream              filter e - gt        try         catch  IOException e    throwWrapped e                            catch  WrappedException w        throw  IOException  w cause      Here  what you re doing is catching the exception in the lambda  throwing a signal out of the stream pipeline that indicates that the computation failed exceptionally  catching the signal  and acting on that signal to throw the underlying exception   The key is that you are always catching the synthetic exception  rather than allowing a checked exception to leak out without declaring that exception is thrown

User · Answer

I wrote a library that extends the Stream API to allow you to throw checked exceptions  It uses Brian Goetz s trick   Your code would become  public List lt Class gt  getClasses   throws ClassNotFoundException            Stream lt String gt  classNames            Stream of  java lang Object    java lang Integer    java lang String         return ThrowingStream of classNames  ClassNotFoundException class                  map Class  forName                  collect Collectors toList

User · Answer

This LambdaExceptionUtil helper class lets you use any checked exceptions in Java streams  like this   Stream of  java lang Object    java lang Integer    java lang String          map rethrowFunction Class  forName          collect Collectors toList       Note Class  forName throws ClassNotFoundException  which is checked  The stream itself also throws ClassNotFoundException  and NOT some wrapping unchecked exception   public final class LambdaExceptionUtil     FunctionalInterface public interface Consumer WithExceptions lt T  E extends Exception gt        void accept T t  throws E          FunctionalInterface public interface BiConsumer WithExceptions lt T  U  E extends Exception gt        void accept T t  U u  throws E          FunctionalInterface public interface Function WithExceptions lt T  R  E extends Exception gt        R apply T t  throws E          FunctionalInterface public interface Supplier WithExceptions lt T  E extends Exception gt        T get   throws E          FunctionalInterface public interface Runnable WithExceptions lt E extends Exception gt        void run   throws E              forEach rethrowConsumer name - gt  System out println Class forName name      or  forEach rethrowConsumer ClassNameUtil  println       public static  lt T  E extends Exception gt  Consumer lt T gt  rethrowConsumer Consumer WithExceptions lt T  E gt  consumer  throws E       return t - gt            try   consumer accept t             catch  Exception exception    throwAsUnchecked exception                       public static  lt T  U  E extends Exception gt  BiConsumer lt T  U gt  rethrowBiConsumer BiConsumer WithExceptions lt T  U  E gt  biConsumer  throws E       return  t  u  - gt            try   biConsumer accept t  u             catch  Exception exception    throwAsUnchecked exception                            map rethrowFunction name - gt  Class forName name    or  map rethrowFunction Class  forName      public static  lt T  R  E extends Exception gt  Function lt T  R gt  rethrowFunction Function WithExceptions lt T  R  E gt  function  throws E       return t - gt            try   return function apply t             catch  Exception exception    throwAsUnchecked exception   return null                          rethrowSupplier    - gt  new StringJoiner new String new byte   77  97  114  107    UTF-8         public static  lt T  E extends Exception gt  Supplier lt T gt  rethrowSupplier Supplier WithExceptions lt T  E gt  function  throws E       return    - gt            try   return function get              catch  Exception exception    throwAsUnchecked exception   return null                          uncheck    - gt  Class forName  xxx        public static void uncheck Runnable WithExceptions t            try   t run          catch  Exception exception    throwAsUnchecked exception                uncheck    - gt  Class forName  xxx        public static  lt R  E extends Exception gt  R uncheck Supplier WithExceptions lt R  E gt  supplier            try   return supplier get          catch  Exception exception    throwAsUnchecked exception   return null               uncheck Class  forName   xxx       public static  lt T  R  E extends Exception gt  R uncheck Function WithExceptions lt T  R  E gt  function  T t        try   return function apply t         catch  Exception exception    throwAsUnchecked exception   return null            SuppressWarnings   unchecked   private static  lt E extends Throwable gt  void throwAsUnchecked Exception exception  throws E   throw  E exception         Many other examples on how to use it  after statically importing LambdaExceptionUtil     Test public void test Consumer with checked exceptions   throws IllegalAccessException       Stream of  java lang Object    java lang Integer    java lang String              forEach rethrowConsumer className - gt  System out println Class forName className           Stream of  java lang Object    java lang Integer    java lang String              forEach rethrowConsumer System out  println            Test public void test Function with checked exceptions   throws ClassNotFoundException       List lt Class gt  classes1             Stream of  Object    Integer    String                      map rethrowFunction className - gt  Class forName  java lang     className                       collect Collectors toList          List lt Class gt  classes2             Stream of  java lang Object    java lang Integer    java lang String                      map rethrowFunction Class  forName                      collect Collectors toList             Test public void test Supplier with checked exceptions   throws ClassNotFoundException       Collector of            rethrowSupplier    - gt  new StringJoiner new String new byte   77  97  114  107    UTF-8                StringJoiner  add  StringJoiner  merge  StringJoiner  toString           Test     public void test uncheck exception thrown by method         Class clazz1   uncheck    - gt  Class forName  java lang String          Class clazz2   uncheck Class  forName   java lang String            Test  expected   ClassNotFoundException class  public void test if correct exception is still thrown by method         Class clazz3   uncheck Class  forName   INVALID                NOTE 1  The rethrow methods of the LambdaExceptionUtil class above may be used without fear  and are OK to use in any situation  A big thanks to user  PaoloC who helped solve the last problem  Now the compiler will ask you to add throw clauses and everything s as if you could throw checked exceptions natively on Java 8 streams     NOTE 2  The uncheck methods of the LambdaExceptionUtil class above are bonus methods  and may be safely removed them from the class if you don t want to use them  If you do used them  do it with care  and not before understanding the following use cases  advantages disadvantages and limitations       You may use the uncheck methods if you are calling a method which literally can never throw the exception that it declares  For example  new String byteArr   UTF-8   throws UnsupportedEncodingException  but UTF-8 is guaranteed by the Java spec to always be present  Here  the throws declaration is a nuisance and any solution to silence it with minimal boilerplate is welcome  String text   uncheck    - gt  new String byteArr   UTF-8          You may use the uncheck methods if you are implementing a strict interface where you don t have the option for adding a throws declaration  and yet throwing an exception is entirely appropriate  Wrapping an exception just to gain the privilege of throwing it results in a stacktrace with spurious exceptions which contribute no information about what actually went wrong  A good example is Runnable run    which does not throw any checked exceptions       In any case  if you decide to use the uncheck methods   be aware of these 2 consequences of throwing CHECKED exceptions without a throws clause  1  The calling-code won t be able to catch it by name  if you try  the compiler will say  Exception is never thrown in body of corresponding try statement   It will bubble and probably be caught in the main program loop by some  catch Exception  or  catch Throwable   which may be what you want anyway  2  It violates the principle of least surprise  it will no longer be enough to catch RuntimeException to be able to guarantee catching all possible exceptions  For this reason  I believe this should not be done in framework code  but only in business code that you completely control    References    http   www philandstuff com 2012 04 28 sneakily-throwing-checked-exceptions html http   www mail-archive com javaposse googlegroups com msg05984 html Project Lombok annotation   SneakyThrows Brian Goetz opinion  against  here  How can I throw CHECKED exceptions from inside Java 8 streams  https   softwareengineering stackexchange com questions 225931 workaround-for-java-checked-exceptions newreg ddf0dd15e8174af8ba52e091cf85688e

User · Answer

TL DR Just use Lombok s  SneakyThrows   Christian Hujer has already explained in detail why throwing checked exceptions from a stream is  strictly speaking  not possible due to Java s limitations    Some other answers have explained tricks to get around the limitations of the language but still being able to fulfil the requirement of throwing  the checked exception itself  and without adding ugly try catches to the stream   some of them requiring tens of additional lines of boilerplate    I am going to highlight another option for doing this that IMHO is far cleaner than all the others  Lombok s  SneakyThrows  It has been mentioned in passing by other answers but was a bit buried under a lot of unnecessary detail    The resulting code is as simple as    public List lt Class gt  getClasses   throws ClassNotFoundException       List lt Class gt  classes           Stream of  java lang Object    java lang Integer    java lang String                    map className - gt  getClass className                    collect Collectors toList         return classes      SneakyThrows                                     lt   this is the only new code private Class lt   gt  getClass String className        return Class forName className       We just needed one Extract Method refactoring  done by the IDE  and one additional line for  SneakyThrows  The annotation takes care of adding all the boilerplate to make sure that you can throw your checked exception without wrapping it in a RuntimeException and without needing to declare it explicitly

User · Answer

Summarizing the comments above the advanced solution is to use a special wrapper for unchecked functions with builder like API which provides recovering  rethrowing and suppresing   Stream of  java lang Object    java lang Integer    java lang String              map Try  lt String  Class lt   gt  gt safe Class  forName                     handle System out  println                     unsafe               collect toList       Code below demonstrates it for Consumer  Supplier and Function interfaces  It can be easly expanded  Some public keywords were removed for this example   Class Try is the endpoint for client code  Safe methods may have unique name for each function type  CheckedConsumer  CheckedSupplier and CheckedFunction are checked analogs of lib functions which can be used independently of Try  CheckedBuilder is the interface for handling exceptions in some checked function  orTry allows execute another same type function if previous was failed  handle provides exception handling including exception type filtering  The order of handlers is important  Reduce methods unsafe and rethrow rethrows last exception in  the execution chain  Reduce methods orElse and orElseGet return alternate value like Optional ones if all functions failed  Also there is method suppress   CheckedWrapper is the common implementation of CheckedBuilder   final class Try        public static  lt T gt  CheckedBuilder lt Supplier lt T gt   CheckedSupplier lt T gt   T gt           safe CheckedSupplier lt T gt  supplier            return new CheckedWrapper lt  gt  supplier                    current  next  handler  orResult  - gt     - gt                try   return current get      catch  Exception ex                    handler accept ex                   return next isPresent     next get   get     orResult apply ex                                        public static  lt T gt  Supplier lt T gt  unsafe CheckedSupplier lt T gt  supplier            return supplier             public static  lt T gt  CheckedBuilder lt Consumer lt T gt   CheckedConsumer lt T gt   Void gt           safe CheckedConsumer lt T gt  consumer            return new CheckedWrapper lt  gt  consumer                    current  next  handler  orResult  - gt  t - gt                try   current accept t     catch  Exception ex                    handler accept ex                   if  next isPresent                          next get   accept t                     else                       orResult apply ex                                                          public static  lt T gt  Consumer lt T gt  unsafe CheckedConsumer lt T gt  consumer            return consumer             public static  lt T  R gt  CheckedBuilder lt Function lt T  R gt   CheckedFunction lt T  R gt   R gt           safe CheckedFunction lt T  R gt  function            return new CheckedWrapper lt  gt  function                    current  next  handler  orResult  - gt  t - gt                try   return current applyUnsafe t     catch  Exception ex                    handler accept ex                   return next isPresent     next get   apply t    orResult apply ex                                        public static  lt T  R gt  Function lt T  R gt  unsafe CheckedFunction lt T  R gt  function            return function              SuppressWarnings   unchecked       static  lt T  E extends Throwable gt  T throwAsUnchecked Throwable exception  throws E            throw  E  exception             FunctionalInterface interface CheckedConsumer lt T gt  extends Consumer lt T gt        void acceptUnsafe T t  throws Exception       Override default void accept T t            try   acceptUnsafe t     catch  Exception ex                Try throwAsUnchecked ex                       FunctionalInterface interface CheckedFunction lt T  R gt  extends Function lt T  R gt        R applyUnsafe T t  throws Exception       Override default R apply T t            try   return applyUnsafe t     catch  Exception ex                return Try throwAsUnchecked ex                       FunctionalInterface interface CheckedSupplier lt T gt  extends Supplier lt T gt        T getUnsafe   throws Exception       Override default T get             try   return getUnsafe      catch  Exception ex                return Try throwAsUnchecked ex                      interface ReduceFunction lt TSafe  TUnsafe  R gt        TSafe wrap TUnsafe current  Optional lt TSafe gt  next               Consumer lt Throwable gt  handler  Function lt Throwable  R gt  orResult      interface CheckedBuilder lt TSafe  TUnsafe  R gt        CheckedBuilder lt TSafe  TUnsafe  R gt  orTry TUnsafe next        CheckedBuilder lt TSafe  TUnsafe  R gt  handle Consumer lt Throwable gt  handler         lt E extends Throwable gt  CheckedBuilder lt TSafe  TUnsafe  R gt  handle              Class lt E gt  exceptionType  Consumer lt E gt  handler        CheckedBuilder lt TSafe  TUnsafe  R gt  handleLast Consumer lt Throwable gt  handler         lt E extends Throwable gt  CheckedBuilder lt TSafe  TUnsafe  R gt  handleLast              Class lt E gt  exceptionType  Consumer lt   super E gt  handler        TSafe unsafe        TSafe rethrow Function lt Throwable  Exception gt  transformer       TSafe suppress        TSafe orElse R value       TSafe orElseGet Supplier lt R gt  valueProvider      final class CheckedWrapper lt TSafe  TUnsafe  R gt           implements CheckedBuilder lt TSafe  TUnsafe  R gt         private final TUnsafe function      private final ReduceFunction lt TSafe  TUnsafe  R gt  reduceFunction       private final CheckedWrapper lt TSafe  TUnsafe  R gt  root      private CheckedWrapper lt TSafe  TUnsafe  R gt  next       private Consumer lt Throwable gt  handlers   ex - gt           private Consumer lt Throwable gt  lastHandlers   ex - gt            CheckedWrapper TUnsafe function               ReduceFunction lt TSafe  TUnsafe  R gt  reduceFunction            this function   function          this reduceFunction   reduceFunction          this root   this             private CheckedWrapper TUnsafe function               CheckedWrapper lt TSafe  TUnsafe  R gt  prev            this function   function          this reduceFunction   prev reduceFunction          this root   prev root          prev next   this              Override public CheckedBuilder lt TSafe  TUnsafe  R gt  orTry TUnsafe next            return new CheckedWrapper lt  gt  next  this               Override public CheckedBuilder lt TSafe  TUnsafe  R gt  handle              Consumer lt Throwable gt  handler            handlers   handlers andThen handler           return this              Override public  lt E extends Throwable gt  CheckedBuilder lt TSafe  TUnsafe  R gt           handle Class lt E gt  exceptionType  Consumer lt E gt  handler            handlers   handlers andThen ex - gt                if  exceptionType isInstance ex                     handler accept exceptionType cast ex                                      return this              Override public CheckedBuilder lt TSafe  TUnsafe  R gt  handleLast              Consumer lt Throwable gt  handler            lastHandlers   lastHandlers andThen handler           return this              Override public  lt E extends Throwable gt  CheckedBuilder lt TSafe  TUnsafe  R gt           handleLast Class lt E gt  exceptionType  Consumer lt   super E gt  handler            lastHandlers   lastHandlers andThen ex - gt                if  exceptionType isInstance ex                     handler accept exceptionType cast ex                                      return this              Override public TSafe unsafe             return root reduce ex - gt  Try throwAsUnchecked ex                Override     public TSafe rethrow Function lt Throwable  Exception gt  transformer            return root reduce ex - gt  Try throwAsUnchecked transformer apply ex                 Override public TSafe suppress             return root reduce ex - gt  null               Override public TSafe orElse R value            return root reduce ex - gt  value               Override public TSafe orElseGet Supplier lt R gt  valueProvider            Objects requireNonNull valueProvider           return root reduce ex - gt  valueProvider get                private TSafe reduce Function lt Throwable  R gt  orResult            return reduceFunction wrap function                   Optional ofNullable next  map p - gt  p reduce orResult                     this  handle  orResult              private void handle Throwable ex            for  CheckedWrapper lt TSafe  TUnsafe  R gt  current   this                   current    null                   current   current next                current handlers accept ex                     lastHandlers accept ex

User · Answer

I use this kind of wrapping exception   public class CheckedExceptionWrapper extends RuntimeException               public  lt T extends Exception gt  CheckedExceptionWrapper rethrow   throws T           throw  T  getCause              It will require handling these exceptions statically   void method   throws IOException  ServletException       try            list stream   forEach object - gt                                throw new CheckedExceptionWrapper e                                                 catch  CheckedExceptionWrapper e           e  lt IOException gt rethrow            e  lt ServletExcepion gt rethrow              Try it online   Though exception will be anyway re-thrown during first rethrow   call  oh  Java generics      this way allows to get a strict statical definition of possible exceptions  requires to declare them in throws   And no instanceof or something is needed

User · Answer

The only built-in way of handling checked exceptions that can be thrown by a map operation is to encapsulate them within a CompletableFuture    An Optional is a simpler alternative if you don t need to preserve the exception    These classes are intended to allow you to represent contingent operations in a functional way   A couple of non-trivial helper methods are required  but you can arrive at code that s relatively concise  while still making it apparent that your stream s result is contingent on the map operation having completed successfully   Here s what it looks like       CompletableFuture lt List lt Class lt   gt  gt  gt  classes               Stream of  java lang String    java lang Integer    java lang Double                      map MonadUtils applyOrDie Class  forName                      map cfc - gt  cfc thenApply Class  getSuperclass                      collect MonadUtils cfCollector ArrayList  new                                                    List  add                                                     List lt Class lt   gt  gt  l1  List lt Class lt   gt  gt  l2  - gt    l1 addAll l2   return l1                                                       x - gt  x        classes thenAccept System out  println              exceptionally t - gt    System out println  unable to get class      t   return null        This produces the following output    class java lang Object  class java lang Number  class java lang Number    The applyOrDie method takes a Function that throws an exception  and converts it into a Function that returns an already-completed CompletableFuture -- either completed normally with the original function s result  or completed exceptionally with the thrown exception   The second map operation illustrates that you ve now got a Stream lt CompletableFuture lt T gt  gt  instead of just a Stream lt T gt    CompletableFuture takes care of only executing this operation if the upstream operation succeeded   The API makes this explict  but relatively painless     Until you get to the collect phase  that is   This is where we require a pretty significant helper method   We want to  lift  a normal collection operation  in this case  toList     inside  the CompletableFuture --  cfCollector   lets us do that using a supplier  accumulator  combiner  and finisher that don t need to know anything at all about CompletableFuture   The helper methods can be found on GitHub in my MonadUtils class  which is very much still a work in progress

User · Answer

You can   Extending  marcg  s UtilException and adding throw E where necessary  this way  the compiler will ask you to add throw clauses and everything s as if you could throw checked exceptions natively on java 8 s streams   Instructions  just copy paste LambdaExceptionUtil in your IDE and then use it as shown in the below LambdaExceptionUtilTest   public final class LambdaExceptionUtil         FunctionalInterface     public interface Consumer WithExceptions lt T  E extends Exception gt            void accept T t  throws E              FunctionalInterface     public interface Function WithExceptions lt T  R  E extends Exception gt            R apply T t  throws E                         forEach rethrowConsumer name - gt  System out println Class forName name                  public static  lt T  E extends Exception gt  Consumer lt T gt  rethrowConsumer Consumer WithExceptions lt T  E gt  consumer  throws E           return t - gt                try                   consumer accept t                 catch  Exception exception                    throwActualException exception                                                   map rethrowFunction name - gt  Class forName name    or  map rethrowFunction Class  forName               public static  lt T  R  E extends Exception gt  Function lt T  R gt  rethrowFunction Function WithExceptions lt T  R  E gt  function  throws E            return t - gt                try                   return function apply t                 catch  Exception exception                    throwActualException exception                   return null                                       SuppressWarnings  unchecked       private static  lt E extends Exception gt  void throwActualException Exception exception  throws E           throw  E  exception             Some test to show usage and behaviour   public class LambdaExceptionUtilTest         Test expected   MyTestException class      public void testConsumer   throws MyTestException           Stream of  String null  forEach rethrowConsumer s - gt  checkValue s                private void checkValue String value  throws MyTestException           if value  null                throw new MyTestException                         private class MyTestException extends Exception           Test     public void testConsumerRaisingExceptionInTheMiddle             MyLongAccumulator accumulator   new MyLongAccumulator            try               Stream of 2L  3L  4L  null  5L  forEach rethrowConsumer s - gt  accumulator add s                 fail              catch  MyTestException e                assertEquals 9L  accumulator acc                        private class MyLongAccumulator           private long acc   0          public void add Long value  throws MyTestException               if value  null                    throw new MyTestException                              acc    value                        Test     public void testFunction   throws MyTestException           List lt Integer gt  sizes   Stream of  ciao    hello    lt Integer gt map rethrowFunction s - gt  transform s    collect toList             assertEquals 2  sizes size             assertEquals 4  sizes get 0  intValue             assertEquals 5  sizes get 1  intValue                private Integer transform String value  throws MyTestException           if value  null                throw new MyTestException                      return value length                Test expected   MyTestException class      public void testFunctionRaisingException   throws MyTestException           Stream of  ciao   null   hello    lt Integer gt map rethrowFunction s - gt  transform s    collect toList

User · Answer

I agree with the comments above  in using Stream map you are limited to implementing Function which doesn t throw Exceptions   You could however create your own FunctionalInterface that throws as below     FunctionalInterface public interface UseInstance lt T  X extends Throwable gt      void accept T instance  throws X      then implement it using Lambdas or references as shown below   import java io FileWriter  import java io IOException     lambda expressions and the execute around method  EAM  pattern to   manage resources  public class FileWriterEAM      private final FileWriter writer     private FileWriterEAM final String fileName  throws IOException       writer   new FileWriter fileName         private void close   throws IOException       System out println  close called automatically           writer close          public void writeStuff final String message  throws IOException       writer write message                  public static void use final String fileName  final UseInstance lt FileWriterEAM  IOException gt  block  throws IOException        final FileWriterEAM writerEAM   new FileWriterEAM fileName           try         block accept writerEAM         finally         writerEAM close                 public static void main final String   args  throws IOException        FileWriterEAM use  eam txt   writerEAM - gt  writerEAM writeStuff  sweet          FileWriterEAM use  eam2 txt   writerEAM - gt            writerEAM writeStuff  how            writerEAM writeStuff  sweet                         FileWriterEAM use  eam3 txt   FileWriterEAM  writeIt                void writeIt   throws IOException       this writeStuff  How          this writeStuff  sweet          this writeStuff  it is

[java] How can I throw CHECKED exceptions from inside Java 8 streams?

Examples related to java

Examples related to lambda

Examples related to java-8

Examples related to java-stream

Examples related to checked-exceptions