Java 8 Lambda函数抛出异常？

Question

我知道如何创建对具有string参数并返回int的方法的引用，它是：

Function<String, Integer>

但是，如果函数抛出异常（假设它被定义为：

Integer myMethod(String s) throws IOException

我如何定义这个引用？

Answer 1

实际上，您可以使用处理异常的新接口扩展consumer（和function等）--使用Java 8的默认方法！

请考虑此接口(extendsconsumer):

@FunctionalInterface
public interface ThrowingConsumer<T> extends Consumer<T> {

    @Override
    default void accept(final T elem) {
        try {
            acceptThrows(elem);
        } catch (final Exception e) {
            // Implement your own exception handling logic here..
            // For example:
            System.out.println("handling an exception...");
            // Or ...
            throw new RuntimeException(e);
        }
    }

    void acceptThrows(T elem) throws Exception;

}

然后，例如，如果您有一个列表：

final List<String> list = Arrays.asList("A", "B", "C");

如果您想用一些抛出异常的代码来使用它（例如，使用foreach)，那么您通常会设置一个try/catch块：

final Consumer<String> consumer = aps -> {
    try {
        // maybe some other code here...
        throw new Exception("asdas");
    } catch (final Exception ex) {
        System.out.println("handling an exception...");
    }
};
list.forEach(consumer);

但是有了这个新接口，您可以用lambda表达式实例化它，编译器就不会抱怨了：

final ThrowingConsumer<String> throwingConsumer = aps -> {
    // maybe some other code here...
    throw new Exception("asdas");
};
list.forEach(throwingConsumer);

或者干脆把它铸得更简洁！：

list.forEach((ThrowingConsumer<String>) aps -> {
    // maybe some other code here...
    throw new Exception("asda");
});

更新：看起来Durian中有一个非常好的实用程序库，叫做Errors，它可以用来解决这个问题，并且具有更大的灵活性。例如，在上面的实现中，我显式定义了错误处理策略(system.out...或throw runtimeexception)，而Durian的错误允许您通过一大套实用工具方法即时应用策略。谢谢分享，@nedtwigg！

示例用法：

list.forEach(Errors.rethrow().wrap(c -> somethingThatThrows(c)));

Answer 2

您需要执行以下操作之一。

>

如果是您的代码，则定义您自己的函数接口来声明检查的异常：

@FunctionalInterface
public interface CheckedFunction<T, R> {
   R apply(T t) throws IOException;
}

并使用它：

void foo (CheckedFunction f) { ... }

否则，将integer myMethod（String s)包装在一个不声明检查异常的方法中：

public Integer myWrappedMethod(String s) {
    try {
        return myMethod(s);
    }
    catch(IOException e) {
        throw new UncheckedIOException(e);
    }
}

后来呢：

Function<String, Integer> f = (String t) -> myWrappedMethod(t);

或：

Function<String, Integer> f =
    (String t) -> {
        try {
           return myMethod(t);
        }
        catch(IOException e) {
            throw new UncheckedIOException(e);
        }
    };