java - Java 8：Lambda-Streams，按异常方法过滤

Question

我在尝试 Java 8 的 Lambda 表达式时遇到问题。通常它可以正常工作，但现在我有了 throwIOException的方法。最好看看下面的代码：

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

我怎样才能让它工作？有人可以提示我正确的解决方案吗？

score 228 · Accepted Answer

您必须在它转义 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要捕获的，如果你试图捕获它，编译器实际上会抱怨，因为我们已经欺骗它相信不会抛出这样的异常。

score 33 · Accepted Answer

你也可以用 lambdas 传播你的静态痛苦，所以整个事情看起来是可读的：

s.filter(a -> propagate(a::isActive))

propagate这里接收java.util.concurrent.Callable作为参数并将调用期间捕获的任何异常转换为RuntimeException. Guava中也有类似的转换方法Throwables#propagate(Throwable)。

这种方法似乎对于 lambda 方法链接是必不可少的，所以我希望有一天它会被添加到流行的库之一中，或者默认情况下这种传播行为。

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

score 22 · Accepted Answer

这个UtilException帮助类允许您在 Java 流中使用任何已检查的异常，如下所示：

Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
      .map(rethrowFunction(Class::forName))
      .collect(Collectors.toList());

注意Class::forNamethrows 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 子句（如果你不这样做，它会说：Exception is never throw in body of相应的 try 语句）。

• 在任何情况下，您都无法将流本身包围起来以在包含该流的方法内捕获已检查的异常（如果您尝试，编译器会说：在相应的try 语句的主体中永远不会抛出异常）。

• 如果您调用的方法实际上永远不会抛出它声明的异常，那么您不应包含 throws 子句。例如：new String(byteArr, "UTF-8") 抛出 UnsupportedEncodingException，但 Java 规范保证 UTF-8 始终存在。在这里， throws 声明是一种麻烦，欢迎任何使用最少样板来使其静音的解决方案。

• 如果你讨厌检查异常并认为一开始就不应该将它们添加到 Java 语言中（越来越多的人有这种想法，而我不是其中之一），那么就不要将检查异常添加到 Java 语言中。包含流的方法的 throws 子句。然后，受检异常的行为就像未受检异常一样。

• 如果您正在实现一个严格的接口，您没有添加 throws 声明的选项，但抛出异常是完全合适的，那么包装一个异常只是为了获得抛出它的特权会导致带有虚假异常的堆栈跟踪它没有提供有关实际问题的信息。一个很好的例子是 Runnable.run()，它不会抛出任何已检查的异常。在这种情况下，您可能决定不将检查的异常添加到包含流的方法的 throws 子句中。

• 在任何情况下，如果您决定不向包含流的方法的 throws 子句添加（或忘记添加）已检查异常，请注意引发 CHECKED 异常的以下 2 个后果：

1）调用代码将无法通过名称捕获它（如果您尝试，编译器会说：异常不会在相应的try语句体中抛出）。它会冒泡，并且可能在主程序循环中被一些“catch Exception”或“catch Throwable”捕获，这可能是你想要的。

2）它违反了最小意外原则：捕获 RuntimeException 已经不足以保证捕获所有可能的异常。出于这个原因，我认为这不应该在框架代码中完成，而只能在您完全控制的业务代码中完成。

结论：我认为这里的限制并不严重，UtilException可以放心使用该类。然而，这取决于你！

参考：
- http://www.philandstuff.com/2012/04/28/sneakily-throwing-checked-exceptions.html
- http://www.mail-archive.com/javaposse@googlegroups.com/msg05984.html
- Lombok 项目注解：@SneakyThrows
- Brian Goetz 的观点（反对）在这里：如何从 Java 8 流中抛出 CHECKED 异常？
- https://softwareengineering.stackexchange.com/questions/225931/workaround-for-java-checked-exceptions?newreg=ddf0dd15e8174af8ba52e091cf85688e *

score 11 · Accepted Answer

Stream您可以通过包装您的 lambda 以引发未经检查的异常，然后在终端操作上解开该未经检查的异常来潜在地滚动您自己的变体：

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

然后你可以使用与 a 相同的方式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());

这个解决方案需要相当多的样板文件，所以我建议你看看我已经制作的库，它完全符合我在此处为整个Stream课程描述的内容（还有更多！）。

score 5 · Accepted Answer

使用#propagate() 方法。Sam Beran 的 Java 8 博客中的非 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);
        }
    }
}

score 4 · Accepted Answer

这并不能直接回答问题（还有许多其他答案可以），而是首先尝试避免该问题：

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

interface Account {
    boolean isActive() throws IOException;
    String getNumber() throws IOException;
}

IOException考虑这样的设计，而不是在每个 getter 上抛出一个：

interface AccountReader {
    Account readAccount(…) throws IOException;
}

interface Account {
    boolean isActive();
    String getNumber();
}

该方法AccountReader.readAccount(…)可以从数据库或文件或其他任何内容中读取帐户，如果不成功则抛出异常。它构造了一个Account已经包含所有值的对象，可以使用。由于值已经被加载readAccount(…)，getter 不会抛出异常。因此，您可以在 lambda 中自由地使用它们，而无需包装、屏蔽或隐藏异常。

当然，并非总是可以按照我描述的方式进行操作，但通常是这样，并且它会导致代码更清晰（恕我直言）：

更好地分离关注点并遵循单一职责原则
更少的样板：你不必throws IOException为了满足编译器的需要而把你的代码弄得乱七八糟
错误处理：你处理错误发生的地方——从文件或数据库中读取——而不是仅仅因为你想获得一个字段值而在你的业务逻辑中间的某个地方
您可能能够使Account 不可变并从其优点中获利（例如线程安全）
您不需要Account在 lambdas 中使用“肮脏的技巧”或变通方法（例如在 a 中Stream）

score 3 · Accepted Answer

扩展@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
    }
}

score 3 · Accepted Answer

它可以通过以下简单代码在AbacusUtil中使用 Stream和Try来解决：

Stream.of(accounts).filter(a -> Try.call(a::isActive)).map(a -> Try.call(a::getNumber)).toSet();

披露：我是AbacusUtil.

score 2 · Accepted Answer

要正确添加 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必须将捕获为 aRuntimeException并将其转换回IOException-- 并且这将为上述方法添加更多代码。

Stream当它可以像这样完成时为什么要使用- 并且该方法会抛出IOException，因此也不需要额外的代码：

Set<String> set = new HashSet<>();
for(Account a: accounts.values()){
  if(a.isActive()){
     set.add(a.getNumber());
  } 
}
return set;

score 1 · Accepted Answer

牢记这个问题，我开发了一个小型库来处理检查异常和 lambda。自定义适配器允许您与现有的功能类型集成：

stream().map(unchecked(URI::new)) //with a static import

https://github.com/TouK/ThrowingFunction/

score 1 · Accepted Answer

It's also possible to use some external (to stream) error indicator for throwing exception at higher level:

List<String> errorMessages = new ArrayList<>(); // error indicator
//..
errorMessages.clear();

List<String> names = new ArrayList<>(Arrays.asList("andrey", "angela", "pamela"));

names.stream()
.map(name -> {
    if (name != "pamela") {
      errorMessages.add(name + " is wrong here!"); 
      return null; // triggering the indicator
    }
    return name;
} )
.filter(elem -> (elem != null)) // bypassing propagation of only current unwanted data
//.filter(elem -> (errorMessages.size() == 0)) // or blocking any propagation once unwanted data detected
.forEach(System.out::println);

if (errorMessages.size() > 0) { // handling the indicator
  throw  new RuntimeException(String,join(", ", errorMessages));
}

score 1 · Accepted Answer

你的例子可以写成：

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

score 0 · Accepted Answer

如果您想在流中处理异常并继续处理其他异常，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;
}

score 0 · Accepted Answer

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

score 0 · Accepted Answer

如果您不介意使用 3rd 方库，AOL 的cyclops-react库，公开::我是贡献者，这里有一个ExceptionSoftener类可以提供帮助。

 s.filter(softenPredicate(a->a.isActive()));

java - Java 8：Lambda-Streams，按异常方法过滤

15 回答 15

Related

Reference