假设我有一个类和一个方法
class A {
void foo() throws Exception() {
...
}
}
现在我想为流传递的每个A实例调用foo：
void bar() throws Exception {
Stream<A> as = ...
as.forEach(a -> a.foo());
}
问题：如何正确处理异常？我的代码在我的电脑上无法编译，因为我没有处理foo()可能抛出的异常。这里bar的throws Exception似乎毫无用处。为什么会这样呢？
你需要将方法调用包装到另一个方法中，在这个方法中你不会抛出已检查异常。你仍然可以抛出任何是RuntimeException子类的异常。
常规的包装惯用语如下：
private void safeFoo(final A a) {
try {
a.foo();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
（超类型异常Exception仅用作示例，永远不要尝试自行捕获它）
然后，您可以这样调用它：as.forEach(this::safeFoo)。
如果你只想调用foo，并且希望按原样传播异常（而不是包装），那么你也可以只使用Java的for循环（在使用一些技巧将流转换为可迭代对象后）：
for (A a : (Iterable<A>) as::iterator) {
a.foo();
}
至少在我的JUnit测试中，这就是我所做的，在那里我不想费心包装我的已检查异常（事实上，我更喜欢我的测试抛出未包装的原始异常）
这个问题可能有点老，但我认为这里的“正确”答案只有一种方式，这可能会导致以后在您的代码中隐藏一些问题。即使存在一些争议，Checked Exceptions的存在是有原因的。
在我看来，最优雅的方法是由Misha在这里给出的Aggregate runtime exceptions in Java 8 streams，只需在“futures”中执行操作。这样，您可以运行所有工作部分并将未工作的Exceptions收集为单个异常。否则，您可以将它们全部收集到一个列表中，稍后再处理它们。
类似的方法来自于Benji Weber。他建议创建自己的类型来收集工作和未工作的部分。
根据您想要实现的内容，输入值和输出值之间的简单映射可能也适合您。
如果您不喜欢任何这些方式，请考虑使用（根据原始异常）至少一个自定义异常。
stream.map(Streams.passException(x->mightThrowException(x))).catch(e->whatToDo(e)).collect(...)。它应该期望异常并允许你像 futures 一样处理它们。 - aalku您可能希望执行以下操作之一：
多个库可以轻松实现这一点。下面的示例使用我的NoException库编写。
// Propagate checked exception
as.forEach(Exceptions.sneak().consumer(A::foo));
// Wrap and propagate unchecked exception
as.forEach(Exceptions.wrap().consumer(A::foo));
as.forEach(Exceptions.wrap(MyUncheckedException::new).consumer(A::foo));
// Catch the exception and stop propagation (using logging handler for example)
as.forEach(Exceptions.log().consumer(Exceptions.sneak().consumer(A::foo)));
我建议使用Google Guava的Throwables类
propagate(Throwable throwable)
如果throwable实例是RuntimeException或Error，则按原样传播它；否则，作为最后的手段，将其包装在RuntimeException中，然后传播。**
void bar() {
Stream<A> as = ...
as.forEach(a -> {
try {
a.foo()
} catch(Exception e) {
throw Throwables.propagate(e);
}
});
}
更新：
现在它已经被弃用，请使用：
void bar() {
Stream<A> as = ...
as.forEach(a -> {
try {
a.foo()
} catch(Exception e) {
Throwables.throwIfUnchecked(e);
throw new RuntimeException(e);
}
});
}
class A {
void foo() throws Exception {
throw new Exception();
}
};
interface Task {
void run() throws Exception;
}
static class TaskException extends RuntimeException {
private static final long serialVersionUID = 1L;
public TaskException(Exception e) {
super(e);
}
}
void bar() throws Exception {
Stream<A> as = Stream.generate(()->new A());
try {
as.forEach(a -> wrapException(() -> a.foo())); // or a::foo instead of () -> a.foo()
} catch (TaskException e) {
throw (Exception)e.getCause();
}
}
static void wrapException(Task task) {
try {
task.run();
} catch (Exception e) {
throw new TaskException(e);
}
}
class A {
void foo() throws MyException() {
...
}
}
只需将其隐藏在 RuntimeException 中，即可通过 forEach()。
void bar() throws MyException {
Stream<A> as = ...
try {
as.forEach(a -> {
try {
a.foo();
} catch(MyException e) {
throw new RuntimeException(e);
}
});
} catch(RuntimeException e) {
throw (MyException) e.getCause();
}
}
尽管在这一点上，如果有人说跳过流而使用for循环，我也不会反对，除非：
Collection.stream()创建您的流，即不能直接将其翻译为for循环。parallelstream()