Java异常处理

在java8使用lambda表达式的时候，不可避免的要调用异常处理机制，下面主要记录受检异常与非受检异常在lambda中的处理。

一、非受检异常处理

例子如下所示：

public static void testUncheckedException(){
        List<Integer> integers = Arrays.asList(5, 10, 11, 32, 40, 60);
        integers.forEach(i ->{
            try {
                System.out.println(50 / i);
            } catch (ArithmeticException e) {
                System.err.println("Arithmetic Exception occurred : " + e.getMessage());
            }
        });
 }

编写包装方法来进行处理：

/**
 * @param consumer 接收一个泛型的参数T，然后调用accept，对这个参数做一系列的操作
 */
private static Consumer<Integer> lambdaWrapper(Consumer<Integer> consumer) {
        return i -> {
            try {
                System.out.println("accepted value is : "+i);
                consumer.accept(i);
            } catch (ArithmeticException e) {
                System.err.println("Arithmetic Exception occurred : " + e.getMessage());
            }
        };
}

public static void testUncheckedException1(){
        List<Integer> integers = Arrays.asList(5, 10, 11, 32, 40, 60);
        integers.forEach(lambdaWrapper(i-> System.out.println(50/i)));
}

对方法加以改进并对异常进行抛出：

private static <T, E extends Exception> Consumer<T> consumerWrapper(Consumer<T> consumer, Class<E> clazz) {
        return i -> {
            try {
                consumer.accept(i);
            } catch (Exception e) {
                try {
                    E eCast = clazz.cast(e);
                    System.err.println("Exception occurred : " + eCast.getMessage());
                } catch (ClassCastException ccEx) {
                    throw e;
                }
            }
        };
}

public static void testUncheckedException2(){
        List<Integer> integers = Arrays.asList(5, 10, 11, 32, 40, 60);
        integers.forEach(
                consumerWrapper(
                        i -> System.out.println(50 / i),
                        ArithmeticException.class));
}

二、受检异常处理

 例子如下所示：

private static void writeToFile(String string) throws IOException {
        File file = new File("c:/newfile.txt");

        try (FileOutputStream fop = new FileOutputStream(file)) {

            if (!file.exists()) {
                file.createNewFile();
            }

            byte[] contentInBytes = string.getBytes();

            fop.write(contentInBytes);
            fop.flush();
            fop.close();

            System.out.println("Done");

        }
}

public static void testCheckedException(){
        List<String> integers = Arrays.asList("3", "9", "7", "0", "10", "20");
        integers.forEach(i -> {
            try {
                writeToFile(i);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
}

可以首先编写一个可以抛出异常的函数式接口：

@FunctionalInterface
public interface ThrowingConsumer<T, E extends Exception> {
    void accept(T t) throws E;
}

private static <T> Consumer<T> throwingConsumerWrapper(ThrowingConsumer<T, Exception> throwingConsumer) {
        return i -> {
            try {
                throwingConsumer.accept(i);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
}

public static void testCheckedException1(){
        List<String> stringS = Arrays.asList("3", "9", "7", "0", "10", "20");
        stringS.forEach(throwingConsumerWrapper(ExceptionHandler::writeToFile));
}

进行优化改造：

private static <T, E extends Exception> Consumer<T> handlingConsumerWrapper(
            ThrowingConsumer<T, E> throwingConsumer, Class<E> exceptionClass) {
        return i -> {
            try {
                throwingConsumer.accept(i);
            } catch (Exception ex) {
                try {
                    E exCast = exceptionClass.cast(ex);
                    System.err.println("Exception occurred : " + exCast.getMessage());
                } catch (ClassCastException ccEx) {
                    throw new RuntimeException(ex);
                }
            }
        };
}

public static void testCheckedException2(){
        List<String> stringList = Arrays.asList("3", "9", "7", "0", "10", "20");
        stringList.forEach(handlingConsumerWrapper(ExceptionHandler::writeToFile, IOException.class));
}

参考原文地址为：http://www.baeldung.com/java-lambda-exceptions