Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "how to solve the problem that Lambda expressions in Java grammar cannot throw exceptions". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Catalogue

Lambda expression cannot throw an exception

1.Demo example

two。 Compiled through

How to handle lambda expression exception

Let's look at an example.

Lambda expression cannot throw exception 1.Demo example

Error message-Unhandled exception: java.io.IOException

Public static void main (String [] args) throws IOException {Stream.of ("a", "b", "c") .forEach (str-> {throw new IOException ();});} 2. Compiled through Stream.of ("a", "b", "c") .forEach (str-> {throw new RuntimeException (new IOException ());}); / / not recommended

Or

Static void doThrow (Exception e) throws E {throw (E) e;} / / compiled through Stream.of ("a", "b", "c") .forEach (str-> {doThrow (new IOException ());}); how should lambda expression exceptions be handled

Lambda expressions are introduced in java 8. Lambda expressions can make our code more brief and business logic clearer, but the Functional Interface used in lambda expressions does not handle exceptions very well, because these Functional Interface provided by JDK usually do not throw exceptions, which means that we have to handle exceptions manually.

Because exceptions are divided into Unchecked Exception and checked Exception, let's discuss them separately.

Dealing with Unchecked Exception

Unchecked exception is also called RuntimeException, and RuntimeException usually occurs because there is something wrong with our code. RuntimeException does not need to be captured. That is, if you have RuntimeException, you can compile without capture.

Let's look at an example: List integers = Arrays.asList (1 System.out.println 2, 3 4, 5); integers.forEach (I-> 1 / I)

This example can be compiled successfully, but there is a problem above. If there is a 0 in list, ArithmeticException will be thrown.

Although this is a Unchecked Exception, we still want to deal with it:

Integers.forEach (I-> {try {System.out.println (1 / I);} catch (ArithmeticException e) {System.err.println ("ArithmeticException occured:" + e.getMessage ());}})

In the above example, we used try,catch to handle exceptions, which is simple but breaks the best practices of lambda expressions. The code becomes bloated.

Let's move try,catch into a wrapper method:

Static Consumer lambdaWrapper (Consumer consumer) {return I-> {try {consumer.accept (I);} catch (ArithmeticException e) {System.err.println ("ArithmeticException occured:" + e.getMessage ());}};}

The original call looks like this:

Integers.forEach (lambdaWrapper (I-> System.out.println (1 / I))

But the above wrapper fixed the capture ArithmeticException, and we adapted it into a more generic class:

Static ConsumerconsumerWrapperWithExceptionClass (Consumerconsumer, Class clazz) {return I-> {try {consumer.accept (I);} catch (Exception ex) {try {E exCast = clazz.cast (ex); System.err.println ("Exception occured:" + exCast.getMessage ()) } catch (ClassCastException ccEx) {throw ex;}};}

The above class passes in a class and cast it to the exception, and if it can cast, handle it, otherwise throw an exception.

After doing this, we call:

Ntegers.forEach (consumerWrapperWithExceptionClass (I-> System.out.println (1 / I), ArithmeticException.class))

Dealing with checked Exception

Checked Exception is an exception that must be handled, so let's look at an example:

Static void throwIOException (Integer integer) throws IOException {} List integers = Arrays.asList (1,2,3,4,5); integers.forEach (I-> throwIOException (I))

Above we defined a method to throw IOException, which is a checked Exception that needs to be handled, so in the following forEach, the program will fail to compile because the corresponding exception is not handled.

The easiest way is to live in try,catch, as shown below:

Ntegers.forEach (I-> {try {throwIOException (I);} catch (IOException e) {throw new RuntimeException (e);}})

Of course, the disadvantages of this approach have been discussed above, and again, we can define a new wrapper method:

Static Consumer consumerWrapper (ThrowingConsumer throwingConsumer) {return I-> {try {throwingConsumer.accept (I);} catch (Exception ex) {throw new RuntimeException (ex);};}

We call it like this:

Integers.forEach (consumerWrapper (I-> throwIOException (I))

We can also encapsulate the exception:

Static Consumer consumerWrapperWithExceptionClass (ThrowingConsumer throwingConsumer, Class exceptionClass) {return I-> {try {throwingConsumer.accept (I);} catch (Exception ex) {try {E exCast = exceptionClass.cast (ex) System.err.println ("Exception occured:" + exCast.getMessage ());} catch (ClassCastException ccEx) {throw new RuntimeException (ex);};}

Then call the following:

Integers.forEach (consumerWrapperWithExceptionClass (I-> throwIOException (I), IOException.class)); "how to solve the problem that Lambda expressions cannot throw exceptions in Java syntax" ends here. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.