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

Question

以下是两个条件

 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

在筛选器(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

null

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