在lambda中处理lambda中没有try-catch的异常

Question

据我所知，如果lambda实现的抽象方法在其签名中没有throws ，则无法处理lambda中throws 。

我遇到以下代码，它的工作原理。 为什么openStream()不要求处理IOException ？ 我可以在tryWithResources看到try-catch ，但我不明白它背后的机制。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static <AUTOCLOSEABLE extends AutoCloseable, OUTPUT> Supplier<OUTPUT> tryWithResources(
            Callable<AUTOCLOSEABLE> callable, Function<AUTOCLOSEABLE, Supplier<OUTPUT>> function,
            Supplier<OUTPUT> defaultSupplier) {
        return () -> {
            try (AUTOCLOSEABLE autoCloseable = callable.call()) {
                return function.apply(autoCloseable).get();
            } catch (Throwable throwable) {
                return defaultSupplier.get();
            }
        };
    }

    public static <INPUT, OUTPUT> Function<INPUT, OUTPUT> function(Supplier<OUTPUT> supplier) {
        return i -> supplier.get();
    }

    public static void main(String... args) {
        Map<String, Collection<String>> anagrams = new ConcurrentSkipListMap<>();
        int count = tryWithResources(
                () -> new BufferedReader(new InputStreamReader(
                        new URL("http://www.puzzlers.org/pub/wordlists/unixdict.txt").openStream())),
                reader -> () -> reader.lines().parallel().mapToInt(word -> {
                    char[] chars = word.toCharArray();
                    Arrays.parallelSort(chars);
                    String key = Arrays.toString(chars);
                    Collection<String> collection = anagrams.computeIfAbsent(key, function(ArrayList::new));
                    collection.add(word);
                    return collection.size();
                }).max().orElse(0), () -> 0).get();
        anagrams.values().stream().filter(ana -> ana.size() >= count).forEach((list) -> {
            for (String s : list)
                System.out.print(s + " ");
            System.out.println();
        });
    }
}

Answer 1

我已将您的示例简化为核心部分：

public static void main(String[] args) {
    withCallable(() -> new URL("url").openStream()); // compiles
    withSupplier(() -> new URL("url").openStream()); // does not compile
}

public static <T> void withCallable(Callable<T> callable) { }

public static <T> void withSupplier(Supplier<T> callable) { }

如果您尝试使用它，您将看到withCallable将编译正常，但withSupplier不编译; 即使lambda表达式与两个功能接口的签名兼容。

这背后的原因是Callable接口的函数方法，即call() ，声明在其签名中throws Exception 。 Supplier.get()没有。

引用JLS 第11.2.3节 ：

当一个lambda体可以抛出一些异常类E时，如果E是一个经过检查的异常类，并且E不是一个在lambda表达式所针对的函数类型的throws子句中声明的某个类的子类，那么这是一个编译时错误。

Answer 2

据我所知，如果lambda实现的抽象方法在其签名中没有抛出，则无法处理lambda中抛出的异常。

有一种解决方法，称为偷偷摸摸 ; 这里是一个没有功能助手的简单例子 。

通过使用一些静态辅助函数将您的抛出签名转换为非抛出函数，这会使编译器重新抛出已检查的异常，您可以转向

.stream().map(x -> {
  try {
    return this.throwingFunction(x)
  } catch(Exception e) {
    throw new RuntimeException(e);
  }
}).forEach(...)

成

.stream().map(uncheckedFunc(this::throwingFunction)).forEach(...)

不将异常包装到通用运行时异常中。