我在尝试Java 8的Lambda表达式时遇到问题。
通常它工作正常，但现在我有抛出IOException的方法。
最好看一下以下代码：
class Bank{
....
public Set<String> getActiveAccountNumbers() throws IOException {
Stream<Account> s = accounts.values().stream();
s = s.filter(a -> a.isActive());
Stream<String> ss = s.map(a -> a.getNumber());
return ss.collect(Collectors.toSet());
}
....
}
interface Account{
....
boolean isActive() throws IOException;
String getNumber() throws IOException;
....
}
问题是，它不能编译，因为我必须捕获isActive-和getNumber-Methods的可能异常。但即使我明确使用如下所示的try-catch-Block，它仍然无法编译，因为我没有捕获异常。所以要么JDK中存在错误，要么我不知道如何捕获这些异常。
class Bank{
....
//Doesn't compile either
public Set<String> getActiveAccountNumbers() throws IOException {
try{
Stream<Account> s = accounts.values().stream();
s = s.filter(a -> a.isActive());
Stream<String> ss = s.map(a -> a.getNumber());
return ss.collect(Collectors.toSet());
}catch(IOException ex){
}
}
....
}
我怎样才能让它发挥作用？有人能暗示我找到正确的解决方案吗？
答案 0 :(得分：198)
你必须在之前捕获异常它才能逃脱lambda：
s = s.filter(a -> { try { return a.isActive(); }
catch (IOException e) { throw new UncheckedIOException(e); }}});
考虑一下这样一个事实：lambda不会在你编写它的地方进行评估，而是在JDK类中的一些完全不相关的地方进行评估。因此，这将是抛出已检查异常的点，并且在该位置它不会被声明。
您可以使用lambda的包装器来处理它，该包装器将已检查的异常转换为未经检查的异常：
public static <T> T uncheckCall(Callable<T> callable) {
try { return callable.call(); }
catch (RuntimeException e) { throw e; }
catch (Exception e) { throw new RuntimeException(e); }
}
您的示例将写为
return s.filter(a -> uncheckCall(a::isActive))
.map(Account::getNumber)
.collect(toSet());
在我的项目中，我没有包装就处理这个问题;相反，我使用的方法有效地解除了编译器对异常的检查。毋庸置疑，应谨慎处理，项目中的每个人都必须意识到，未声明的情况下可能会出现已检查的异常。这是管道代码：
public static <T> T uncheckCall(Callable<T> callable) {
try { return callable.call(); }
catch (Exception e) { return sneakyThrow(e); }
}
public static void uncheckRun(RunnableExc r) {
try { r.run(); } catch (Exception e) { sneakyThrow(e); }
}
public interface RunnableExc { void run() throws Exception; }
@SuppressWarnings("unchecked")
private static <T extends Throwable> void sneakyThrow(Throwable t) throws T {
throw (T) t;
}
即使IOException没有声明，你也可能会被collect甩在脸上。在大多数但不是所有现实案例中，您都希望重新抛出异常，并将其作为一般失败处理。在所有这些情况下，在清晰度或正确性方面没有任何损失。请注意那些其他情况，您实际上想要在现场对异常作出反应。编译器不会让开发人员知道有一个IOException可以捕获它，如果你试图捕获它，编译器实际上会抱怨它，因为我们已经欺骗它，因为我们相信不会抛出这样的异常。
答案 1 :(得分：27)
你也可以用lambdas传播你的静态疼痛，所以整个事情看起来都是可读的：
s.filter(a -> propagate(a::isActive))
propagate此处接收java.util.concurrent.Callable作为参数，并将调用期间捕获的任何异常转换为RuntimeException。在番石榴中有一种类似的转换方法Throwables#propagate(Throwable)。
这个方法对于lambda方法链接似乎是必不可少的，所以我希望有一天它会被添加到一个流行的lib中，或者这种传播行为将是默认的。
public class PropagateExceptionsSample {
// a simplified version of Throwables#propagate
public static RuntimeException runtime(Throwable e) {
if (e instanceof RuntimeException) {
return (RuntimeException)e;
}
return new RuntimeException(e);
}
// this is a new one, n/a in public libs
// Callable just suits as a functional interface in JDK throwing Exception
public static <V> V propagate(Callable<V> callable){
try {
return callable.call();
} catch (Exception e) {
throw runtime(e);
}
}
public static void main(String[] args) {
class Account{
String name;
Account(String name) { this.name = name;}
public boolean isActive() throws IOException {
return name.startsWith("a");
}
}
List<Account> accounts = new ArrayList<>(Arrays.asList(new Account("andrey"), new Account("angela"), new Account("pamela")));
Stream<Account> s = accounts.stream();
s
.filter(a -> propagate(a::isActive))
.map(a -> a.name)
.forEach(System.out::println);
}
}
答案 2 :(得分：18)
这个UtilException帮助程序类允许您在Java流中使用任何已检查的异常，如下所示：
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.map(rethrowFunction(Class::forName))
.collect(Collectors.toList());
注意Class::forName抛出ClassNotFoundException，已检查。流本身也抛出ClassNotFoundException，而不是包含未经检查的异常。
public final class UtilException {
@FunctionalInterface
public interface Consumer_WithExceptions<T, E extends Exception> {
void accept(T t) throws E;
}
@FunctionalInterface
public interface BiConsumer_WithExceptions<T, U, E extends Exception> {
void accept(T t, U u) throws E;
}
@FunctionalInterface
public interface Function_WithExceptions<T, R, E extends Exception> {
R apply(T t) throws E;
}
@FunctionalInterface
public interface Supplier_WithExceptions<T, E extends Exception> {
T get() throws E;
}
@FunctionalInterface
public interface Runnable_WithExceptions<E extends Exception> {
void run() throws E;
}
/** .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name)))); or .forEach(rethrowConsumer(ClassNameUtil::println)); */
public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) throws E {
return t -> {
try { consumer.accept(t); }
catch (Exception exception) { throwAsUnchecked(exception); }
};
}
public static <T, U, E extends Exception> BiConsumer<T, U> rethrowBiConsumer(BiConsumer_WithExceptions<T, U, E> biConsumer) throws E {
return (t, u) -> {
try { biConsumer.accept(t, u); }
catch (Exception exception) { throwAsUnchecked(exception); }
};
}
/** .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName)) */
public static <T, R, E extends Exception> Function<T, R> rethrowFunction(Function_WithExceptions<T, R, E> function) throws E {
return t -> {
try { return function.apply(t); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
};
}
/** rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))), */
public static <T, E extends Exception> Supplier<T> rethrowSupplier(Supplier_WithExceptions<T, E> function) throws E {
return () -> {
try { return function.get(); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
};
}
/** uncheck(() -> Class.forName("xxx")); */
public static void uncheck(Runnable_WithExceptions t)
{
try { t.run(); }
catch (Exception exception) { throwAsUnchecked(exception); }
}
/** uncheck(() -> Class.forName("xxx")); */
public static <R, E extends Exception> R uncheck(Supplier_WithExceptions<R, E> supplier)
{
try { return supplier.get(); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
}
/** uncheck(Class::forName, "xxx"); */
public static <T, R, E extends Exception> R uncheck(Function_WithExceptions<T, R, E> function, T t) {
try { return function.apply(t); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
}
@SuppressWarnings ("unchecked")
private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E { throw (E)exception; }
}
关于如何使用它的许多其他示例（在静态导入UtilException之后）：
@Test
public void test_Consumer_with_checked_exceptions() throws IllegalAccessException {
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.forEach(rethrowConsumer(className -> System.out.println(Class.forName(className))));
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.forEach(rethrowConsumer(System.out::println));
}
@Test
public void test_Function_with_checked_exceptions() throws ClassNotFoundException {
List<Class> classes1
= Stream.of("Object", "Integer", "String")
.map(rethrowFunction(className -> Class.forName("java.lang." + className)))
.collect(Collectors.toList());
List<Class> classes2
= Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.map(rethrowFunction(Class::forName))
.collect(Collectors.toList());
}
@Test
public void test_Supplier_with_checked_exceptions() throws ClassNotFoundException {
Collector.of(
rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))),
StringJoiner::add, StringJoiner::merge, StringJoiner::toString);
}
@Test
public void test_uncheck_exception_thrown_by_method() {
Class clazz1 = uncheck(() -> Class.forName("java.lang.String"));
Class clazz2 = uncheck(Class::forName, "java.lang.String");
}
@Test (expected = ClassNotFoundException.class)
public void test_if_correct_exception_is_still_thrown_by_method() {
Class clazz3 = uncheck(Class::forName, "INVALID");
}
但在了解以下优点，缺点和限制之前不要使用它：
•如果调用代码要处理已检查的异常，则必须将其添加到包含该流的方法的throws子句中。 编译器不会强迫你再添加它，因此更容易忘记它。
•如果调用代码已经处理了已检查的异常，编译器将提醒您将throws子句添加到方法声明中 包含流（如果你不这样做会说：异常永远不会在相应的try语句的主体中抛出）。
•在任何情况下，您都无法围绕流本身来捕获已检查的异常INSIDE包含该流的方法 （如果你尝试，编译器会说：异常永远不会在相应的try语句的主体中抛出）。
•如果您正在调用一个字面上永远不会抛出它声明的异常的方法，那么您不应该包含throws子句。 例如：new String（byteArr，“UTF-8”）抛出UnsupportedEncodingException，但Java规范保证UTF-8始终存在。 在这里，投掷声明是令人讨厌的，任何解决方案，以最小的样板沉默它是受欢迎的。
•如果你讨厌检查异常，并认为永远不应该将它们添加到Java语言中（越来越多的人这样认为， 并且我不是其中之一），然后只是不要将已检查的异常添加到包含流的方法的throws子句中。检查 然后，异常将表现得像UNchecked异常。
•如果您正在实现一个严格的接口，在那里您没有添加throws声明的选项，但是抛出异常是 完全合适，然后包装异常只是为了获得抛出它的特权导致带有虚假异常的堆栈跟踪 没有提供有关实际出错的信息。一个很好的例子是Runnable.run（），它不会抛出任何已检查的异常。 在这种情况下，您可以决定不将已检查的异常添加到包含该流的方法的throws子句中。
•在任何情况下，如果您决定不将（但忘记添加）已检查的异常添加到包含流的方法的throws子句中， 注意抛出CHECKED异常的这两个后果：
1）调用代码将无法按名称捕获它（如果你尝试，编译器会说：异常永远不会抛出相应的试验体内 声明）。它会冒泡并可能在主程序循环中被一些“捕获异常”或“捕获Throwable”捕获，这可能是你的 无论如何都要。
2）它违反了最少惊喜的原则：捕获RuntimeException以便能够保证全部捕获它将不再足够 可能的例外。出于这个原因，我认为这不应该在框架代码中完成，而只能在您完全控制的业务代码中完成。
总之：我认为这里的限制并不严重，UtilException类可以毫无畏惧地使用。但是，这取决于你！
答案 3 :(得分：8)
您可以通过包装lambda来抛出一个未经检查的异常，然后在终端操作中展开该未经检查的异常，从而推出自己的Stream变体：
@FunctionalInterface
public interface ThrowingPredicate<T, X extends Throwable> {
public boolean test(T t) throws X;
}
@FunctionalInterface
public interface ThrowingFunction<T, R, X extends Throwable> {
public R apply(T t) throws X;
}
@FunctionalInterface
public interface ThrowingSupplier<R, X extends Throwable> {
public R get() throws X;
}
public interface ThrowingStream<T, X extends Throwable> {
public ThrowingStream<T, X> filter(
ThrowingPredicate<? super T, ? extends X> predicate);
public <R> ThrowingStream<T, R> map(
ThrowingFunction<? super T, ? extends R, ? extends X> mapper);
public <A, R> R collect(Collector<? super T, A, R> collector) throws X;
// etc
}
class StreamAdapter<T, X extends Throwable> implements ThrowingStream<T, X> {
private static class AdapterException extends RuntimeException {
public AdapterException(Throwable cause) {
super(cause);
}
}
private final Stream<T> delegate;
private final Class<X> x;
StreamAdapter(Stream<T> delegate, Class<X> x) {
this.delegate = delegate;
this.x = x;
}
private <R> R maskException(ThrowingSupplier<R, X> method) {
try {
return method.get();
} catch (Throwable t) {
if (x.isInstance(t)) {
throw new AdapterException(t);
} else {
throw t;
}
}
}
@Override
public ThrowingStream<T, X> filter(ThrowingPredicate<T, X> predicate) {
return new StreamAdapter<>(
delegate.filter(t -> maskException(() -> predicate.test(t))), x);
}
@Override
public <R> ThrowingStream<R, X> map(ThrowingFunction<T, R, X> mapper) {
return new StreamAdapter<>(
delegate.map(t -> maskException(() -> mapper.apply(t))), x);
}
private <R> R unmaskException(Supplier<R> method) throws X {
try {
return method.get();
} catch (AdapterException e) {
throw x.cast(e.getCause());
}
}
@Override
public <A, R> R collect(Collector<T, A, R> collector) throws X {
return unmaskException(() -> delegate.collect(collector));
}
}
然后您可以使用与Stream：
Stream<Account> s = accounts.values().stream();
ThrowingStream<Account, IOException> ts = new StreamAdapter<>(s, IOException.class);
return ts.filter(Account::isActive).map(Account::getNumber).collect(toSet());
这个解决方案需要相当多的样板，所以我建议你看一下library I already made，这完全符合我在这里描述的整个Stream类（以及更多！）。
答案 4 :(得分：5)
使用#propagate（）方法。从Java 8 Blog by Sam Beran获取非Guava实现示例：
public class Throwables {
public interface ExceptionWrapper<E> {
E wrap(Exception e);
}
public static <T> T propagate(Callable<T> callable) throws RuntimeException {
return propagate(callable, RuntimeException::new);
}
public static <T, E extends Throwable> T propagate(Callable<T> callable, ExceptionWrapper<E> wrapper) throws E {
try {
return callable.call();
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw wrapper.wrap(e);
}
}
}
答案 5 :(得分：4)
可以通过Stream中Try和AbacusUtil下面的简单代码来解决：
Stream.of(accounts).filter(a -> Try.call(a::isActive)).map(a -> Try.call(a::getNumber)).toSet();
披露：我是AbacusUtil的开发者。
答案 6 :(得分：3)
要正确添加IOException（to RuntimeException）处理代码，您的方法将如下所示：
Stream<Account> s = accounts.values().stream();
s = s.filter(a -> { try { return a.isActive(); }
catch (IOException e) { throw new RuntimeException(e); }});
Stream<String> ss = s.map(a -> { try { return a.getNumber() }
catch (IOException e) { throw new RuntimeException(e); }});
return ss.collect(Collectors.toSet());
现在的问题是IOException必须被捕获为RuntimeException并转换回IOException - 这将为上述方法添加更多代码。
为什么在可以这样做时使用Stream - 并且该方法会抛出IOException，因此也不需要额外的代码：
Set<String> set = new HashSet<>();
for(Account a: accounts.values()){
if(a.isActive()){
set.add(a.getNumber());
}
}
return set;
答案 7 :(得分：3)
这并没有直接回答这个问题（还有许多其他答案），但首先试图避免这个问题：
根据我的经验，处理Stream（或其他lambda表达式）中的异常的需要通常来自这样的事实：异常被声明为从不应该抛出它们的方法抛出。这通常来自于将业务逻辑与输入和输出混合。您的Account界面就是一个很好的例子：
interface Account {
boolean isActive() throws IOException;
String getNumber() throws IOException;
}
不要在每个getter上抛出IOException，而应考虑这个设计：
interface AccountReader {
Account readAccount(…) throws IOException;
}
interface Account {
boolean isActive();
String getNumber();
}
方法AccountReader.readAccount(…)可以从数据库或文件或其他内容中读取帐户，如果不成功则抛出异常。它构造了一个Account对象，该对象已包含所有可供使用的值。由于值已由readAccount(…)加载，因此getter不会抛出异常。因此，您可以在lambdas中自由使用它们，而无需包装，屏蔽或隐藏异常。
当然，并不总是可以按照我描述的方式进行，但通常是这样，它会导致更干净的代码（恕我直言）：
throws IOException使您的代码混乱，只是为了满足编译器Account immutable并从中获益（例如，线程安全）Account（例如在Stream中）答案 8 :(得分：2)
扩展@marcg解决方案，您通常可以在Streams中抛出并捕获已检查异常;也就是说，编译器会要求你抓住/重新抛出，就像你在外面的溪流一样!!
@FunctionalInterface
public interface Predicate_WithExceptions<T, E extends Exception> {
boolean test(T t) throws E;
}
/**
* .filter(rethrowPredicate(t -> t.isActive()))
*/
public static <T, E extends Exception> Predicate<T> rethrowPredicate(Predicate_WithExceptions<T, E> predicate) throws E {
return t -> {
try {
return predicate.test(t);
} catch (Exception exception) {
return throwActualException(exception);
}
};
}
@SuppressWarnings("unchecked")
private static <T, E extends Exception> T throwActualException(Exception exception) throws E {
throw (E) exception;
}
然后，您的示例将编写如下（添加测试以更清楚地显示它）：
@Test
public void testPredicate() throws MyTestException {
List<String> nonEmptyStrings = Stream.of("ciao", "")
.filter(rethrowPredicate(s -> notEmpty(s)))
.collect(toList());
assertEquals(1, nonEmptyStrings.size());
assertEquals("ciao", nonEmptyStrings.get(0));
}
private class MyTestException extends Exception { }
private boolean notEmpty(String value) throws MyTestException {
if(value==null) {
throw new MyTestException();
}
return !value.isEmpty();
}
@Test
public void testPredicateRaisingException() throws MyTestException {
try {
Stream.of("ciao", null)
.filter(rethrowPredicate(s -> notEmpty(s)))
.collect(toList());
fail();
} catch (MyTestException e) {
//OK
}
}
答案 9 :(得分：1)
记住这个问题我开发了一个小型库来处理已检查的异常和lambdas。自定义适配器允许您与现有功能类型集成：
stream().map(unchecked(URI::new)) //with a static import
答案 10 :(得分：1)
您的示例可以写成：
// return a temporary vector containing 0 and 1
std::vector<int> inifib() {
std::vector<int> t;
t.push_back(0);
t.push_back(1);
return t;
}
int fib(unsigned int numb) {
static std::vector<int> temp = inifib(); // initialize once the static temp with size 2 and values 0,1
if (numb >= temp.size()) {
int cr = fib(numb-1) + fib(numb - 2);
temp.push_back(cr); // when we are here, temp contains everything up to fib(numb - 1) - just push
}
return temp[numb];
}
Unthrow 课程可以在这里https://github.com/SeregaLBN/StreamUnthrower
答案 11 :(得分：0)
如果你不介意使用第三方库，AOL的cyclops-react lib，披露::我是一个贡献者，有一个ExceptionSoftener类，可以在这里提供帮助。
s.filter(softenPredicate(a->a.isActive()));
答案 12 :(得分：0)
Java中的功能接口未声明任何已检查或未检查的异常。 我们需要从以下方法更改方法的签名：
boolean isActive() throws IOException;
String getNumber() throwsIOException;
收件人：
boolean isActive();
String getNumber();
或使用try-catch块进行处理：
public Set<String> getActiveAccountNumbers() {
Stream<Account> s = accounts.values().stream();
s = s.filter(a ->
try{
a.isActive();
}catch(IOException e){
throw new RuntimeException(e);
}
);
Stream<String> ss = s.map(a ->
try{
a.getNumber();
}catch(IOException e){
throw new RuntimeException(e);
}
);
return ss.collect(Collectors.toSet());
}
另一种选择是编写自定义包装器或使用ThrowingFunction之类的库。 使用该库，我们只需要将依赖项添加到我们的pom.xml中：
<dependency>
<groupId>pl.touk</groupId>
<artifactId>throwing-function</artifactId>
<version>1.3</version>
</dependency>
并使用诸如ThrowingFunction，ThrowingConsumer，ThrowingPredicate，ThrowingRunnable，ThrowingSupplier之类的特定类。
最后，代码如下：
public Set<String> getActiveAccountNumbers() {
return accounts.values().stream()
.filter(ThrowingPredicate.unchecked(Account::isActive))
.map(ThrowingFunction.unchecked(Account::getNumber))
.collect(Collectors.toSet());
}
答案 13 :(得分：0)
我看不到任何处理流（Java -8）中已检查异常的方法，我应用的唯一方法是在流中捕获已检查异常并将其重新抛出为未检查异常。
Arrays.stream(VERSIONS)
.map(version -> TemplateStore.class
.getClassLoader().getResourceAsStream(String.format(TEMPLATE_FILE_MASK, version)))
.map(inputStream -> {
try {
return ((EdiTemplates) JAXBContext.newInstance(EdiTemplates.class).createUnmarshaller()
.unmarshal(inputStream)).getMessageTemplate();
} catch (JAXBException e) {
throw new IllegalArgumentException(ERROR, e);
}})
.flatMap(Collection::stream)
.collect(Collectors.toList());
答案 14 :(得分：0)
如果要处理流中的异常并继续处理其他异常，Brian Vermeer在DZone中有一篇很棒的文章，其中使用了Either概念。它显示了一种处理这种情况的绝妙方法。唯一缺少的是示例代码。这是我使用该文章中的概念进行探索的一个示例。
@Test
public void whenValuePrinted_thenPrintValue() {
List<Integer> intStream = Arrays.asList(0, 1, 2, 3, 4, 5, 6);
intStream.stream().map(Either.liftWithValue(item -> doSomething(item)))
.map(item -> item.isLeft() ? item.getLeft() : item.getRight())
.flatMap(o -> {
System.out.println(o);
return o.isPresent() ? Stream.of(o.get()) : Stream.empty();
})
.forEach(System.out::println);
}
private Object doSomething(Integer item) throws Exception {
if (item == 0) {
throw new Exception("Zero ain't a number!");
} else if (item == 4) {
return Optional.empty();
}
return item;
}