java中Stream API中“filter（）”方法的性能[重复]

Question

我想知道java的流API处理这两种情况的方式是相同的还是不同的？如果它要为每个过滤器执行一个独立的循环，那么我认为在性能方面存在显着差异。你觉得怎么样？

这是两个条件

 1. filter(cond1 && cond2 && cond3)
 2. filter(cond1).filter(cond2).filter(cond3)

例子

List<Employee> emps1 = employees.stream()                                                     
        .filter((Employee e) -> e.name.endsWith("n") && e.salary > 10000 && e.id % 2 == 1)    
        .collect(Collectors.toList());                                                        
                                                                                              
List<Employee> emps2 = employees.stream()                                                     
        .filter(e -> e.name.endsWith("n"))                                                    
        .filter(e -> e.salary > 10000)                                                        
        .filter(e -> e.id % 2 == 1)                                                           
        .collect(Collectors.toList());                                                        

Answer 1

在filter(cond1 && cond2 && cond3) 的情况下，只要任何条件评估为false，条件处理就会停止，例如如果cond1 的计算结果为false，则不会处理其他条件（cond2 和cond3）。同样，如果 cond1 计算为 true，则处理将继续计算 cond2，如果计算结果为 false，则不会计算条件 cond3。

filter(cond1).filter(cond2).filter(cond3)的处理方式也是一样的，从下面的例子可以看出：

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of("one", "two", "three", "four")
        .filter(s -> {
            System.out.println("Hello");
            return s.contains("t");
        })
        .filter(s -> {
            System.out.println("Hi");
            return s.contains("f");
        })
        .forEach(System.out::println);
    }
}

输出：

Hello
Hello
Hi
Hello
Hi
Hello

因此，它没有任何区别，这是一个选择问题。第二个看起来更干净。

---

注意：对于更复杂的表达式，您可以使用Predicate#and，它还有两个好处：

1. 您可以在代码中将Predicate 实现的行为与其他流重用。
2. 更简洁的代码。

演示：

import java.util.function.Predicate;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Predicate<String> containsT = s -> s.contains("t");
        Predicate<String> containsE = s -> s.contains("e");
        
        Stream.of("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")
                .filter(containsT.and(containsE))
                .forEach(System.out::println);
    }
}

输出：

three
eight
ten

但是，它对处理的方式没有任何影响。