Java 8: Lambda-Streams，过滤方法与异常

我在尝试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有bug，要么是我不知道如何捕捉这些异常。

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){
        }
    }
    ....
}

我怎样才能让它工作呢?谁能给我点提示吗?

当前回答

Java中的功能接口不声明任何已检查或未检查的异常。我们需要改变方法的签名:

boolean isActive() throws IOException; 
String getNumber() throwsIOException;

To:

boolean isActive();
String getNumber();

或者用try-catch block处理它:

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());
}

2018-11-30 19:08:13

其他回答

为了正确地添加IOException(到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;

2013-11-04 02:10:18

TLDR:尝试通过重构代码来避免这个问题:将“容易出错”的操作与“安全”的操作分开，只使用lambdas中的安全操作。

细节:

这并没有直接回答问题(有很多其他的答案)，但试图从一开始就避免这个问题:

根据我的经验，在Stream(或其他lambda表达式)中处理异常的需求通常来自这样一个事实，即异常被声明为从不应该抛出的方法抛出。这通常来自于将业务逻辑与输入和输出混合。你的帐户界面就是一个完美的例子:

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中自由地使用它们，而不需要包装、屏蔽或隐藏异常。

注意，您仍然需要处理readAccount(…)抛出的异常。毕竟，这就是异常存在的首要原因。但是假设readAccount(…)是在“其他地方”使用的，即在lambdas之外，在那里你可以使用Java提供的“正常”异常处理机制，即try-catch来处理它或throws来让它“冒泡”。

当然，不可能总是按照我描述的方式来做，但通常是这样的，它会导致更干净的代码(恕我直言):

Better separation of concerns and following single responsibility principle Less boilerplate: You don't have to clutter your code with throws IOException for no use but to satisfy the compiler Error handling: You handle the errors where they happen - when reading from a file or database - instead of somewhere in the middle of your business logic only because you want to get a fields value You may be able to make Account immutable and profit from the advantages thereof (e.g. thread safety) You don't need "dirty tricks" or workarounds to use Account in lambdas (e.g. in a Stream)

2016-04-23 21:36:33

如果您希望处理流中的异常并继续处理其他异常，那么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;
}

2019-09-26 16:35:13

你的例子可以写成:

import utils.stream.Unthrow;

class Bank{
   ....
   public Set<String> getActiveAccountNumbers() {
       return accounts.values().stream()
           .filter(a -> Unthrow.wrap(() -> a.isActive()))
           .map(a -> Unthrow.wrap(() -> a.getNumber()))
           .collect(Collectors.toSet());
   }
   ....
}

Unthrow类可以在这里https://github.com/SeregaLBN/StreamUnthrower

2016-03-04 13:18:01