为什么我不能使用过滤器作为流中的最后一步

Question

我一直被告知，不通过collect和findFirst等方法终止流是不好的做法，但没有真正的反馈，为什么在博客中没有太多关于它的内容。

看看下面的示例，我没有使用大规模的嵌套 if 检查，而是使用 Optional 来取回 List 值。如您所见，我的最后一步是在该流中过滤。这对我来说是预期的，这是为了取回一个列表。为什么这是错误的，我应该如何写它？

import lombok.Getter;
import lombok.Setter;
import java.util.*;

public class Main {
    public static void main(String[] args) {

        RequestBean requestBean = new RequestBean();
        // if I uncomment this I will get the list values printed as expected
//        FruitBean fruitBean = new FruitBean();
//        AnotherBean anotherBean = new AnotherBean();
//        InnerBean innerBean = new InnerBean();
//        requestBean.setFruitBeans(Collections.singletonList(fruitBean));
//        fruitBean.setAnotherBeans(Collections.singletonList(anotherBean));
//        anotherBean.setInnerBeans(Collections.singletonList(innerBean));
//        List<String> beans = Arrays.asList("apple", "orange");
//        innerBean.setBeans(beans);

        List<String> result = getBeanViaOptional(requestBean);

        if(result != null){
            for(String s : result){
                System.out.println(s);
            }
        }else {
            System.out.println("nothing in list");
        }

    }

    private static List<String> getBeanViaOptional(RequestBean bean){
        Optional<List<String>> output = Optional.ofNullable(bean)
                .map(RequestBean::getFruitBeans)
                .map(n -> n.get(0))
                .map(FruitBean::getAnotherBeans)
                .map(n -> n.get(0))
                .map(AnotherBean::getInnerBeans)
                .map(n -> n.get(0))
                .map(InnerBean::getBeans)
                // why is this bad practice to end with a filter. how should I write this then?
                .filter(n -> n.contains("apple"));

        if(!output.isPresent()){
            throw new CustomException();
        }

        return output.get();
    }

    // not using this. just to show that optional was preferable compared to this.
    private static List<String> getBeanViaIfChecks(RequestBean bean){
        if(bean != null){
            if(bean.getFruitBeans() != null){
                if(bean.getFruitBeans().get(0) != null){
                    if(bean.getFruitBeans().get(0).getAnotherBeans() != null){
                        if(bean.getFruitBeans().get(0).getAnotherBeans().get(0) != null){
                            if(bean.getFruitBeans().get(0).getAnotherBeans().get(0).getInnerBeans() != null){
                                if(bean.getFruitBeans().get(0).getAnotherBeans().get(0).getInnerBeans().get(0) != null){
                                    return bean.getFruitBeans().get(0).getAnotherBeans().get(0).getInnerBeans().get(0).getBeans();
                                }
                            }
                        }
                    }
                }
            }
        }
        return null;
    }
}

@Getter
@Setter
class RequestBean{
    List<FruitBean> fruitBeans;
}

@Getter
@Setter
class FruitBean{
    List<AnotherBean> anotherBeans;
}

@Getter
@Setter
class AnotherBean{
    List<InnerBean> innerBeans;
}

@Getter
@Setter
class InnerBean{
    List<String> beans;
}

class CustomException extends RuntimeException{
    // do some custom exception stuff
}

Answer 1

对于流，当没有终端操作时，通常不会执行任何中间操作。您的示例使用“可选”。其操作映射和筛选器与流中的某些中间操作具有相同的名称，但它们是不同的。您的示例在您的问题所问的行中是可以的（不是不好的做法）。

另一件事是（正如Aomine已经指出的）. orElseThrow是获取可选中的值并在没有异常时抛出异常的更短方法。更重要的是，使用. orElseThrow（或. orElse如果有默认值）更安全。Optional.get（）应尽可能避免。如果没有值，您将获得NoSuchElementException。这几乎和不使用可选时获取NullPointerException一样糟糕。以适当的方式使用可选可以保护您免受NullPointerException的影响。

Answer 2

我一直被告知不通过收集和findFirst等方法终止Stream是不好的做法，但没有真正的反馈，说明为什么在博客中没有太多关于它的说法。

这实际上取决于上下文，如果你说“我是否可以用中间操作（例如过滤器）结束一个流，而不是调用终端操作（消耗流的操作）”，那么是的，这是不好的做法，有点毫无意义，因为你刚刚定义了一些标准，但从未要求“结果”。

流是懒惰的，因为它们不做任何事情，除非被终端操作告知，例如< code>collect、< code>findFirst等。

如果你说“从方法返回流是不是不好的做法”，那么可能值得一读这个答案，关于是否应该返回流或集合。

此外，请注意，您的getBeanVia可选逻辑正在可选上运行

如果s在易读性、维护等方面明显更好，那么您使用可选而不是命令式的方法。所以我建议您继续使用这种方法，尽管您可以通过使用orElseThrow对其进行一点改进，即：

return Optional.ofNullable(bean)
               .map(RequestBean::getFruitBeans)
               .map(n -> n.get(0))
               .map(FruitBean::getAnotherBeans)
               .map(n -> n.get(0))
               .map(AnotherBean::getInnerBeans)
               .map(n -> n.get(0))
               .map(InnerBean::getBeans)
               .filter(n -> n.contains("apple"))
               .orElseThrow(CustomException::new);