假设我有一个类和一个方法
class A {
void foo() throws Exception() {
...
}
}
现在我想调用foo的每个实例的A交付的流，如:
void bar() throws Exception {
Stream<A> as = ...
as.forEach(a -> a.foo());
}
问:如何正确地处理异常?代码不能在我的机器上编译，因为我没有处理可能由foo()抛出的异常。bar的抛出异常在这里似乎毫无用处。为什么呢?
当前回答
我建议使用谷歌番石榴投掷类
传播(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);
}
});
}
其他回答
您需要将您的方法调用包装到另一个方法调用中，在该方法调用中不抛出受控异常。您仍然可以抛出任何RuntimeException的子类。
一个正常的包装习语是这样的:
private void safeFoo(final A a) {
try {
a.foo();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
(超类型异常异常仅作为示例，永远不要尝试自己捕获它)
然后你可以用:as.forEach(this::safeFoo)调用它。
可以用这种方式包装和展开异常。
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()
我建议使用谷歌番石榴投掷类
传播(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);
}
});
}
如果你只想调用foo，并且你更喜欢传播异常(不包装)，你也可以只使用Java的for循环(在使用一些技巧将流转换为Iterable之后):
for (A a : (Iterable<A>) as::iterator) {
a.foo();
}
这至少是我在JUnit测试中所做的，我不想麻烦地包装我检查过的异常(实际上更喜欢我的测试抛出未包装的原始异常)
