Java Stream 常用方法【详尽篇】

ゞ浴缸里的玫瑰 2024-03-22 20:32 69阅读 0赞

#### 1.Stream API 介绍 ####

Java8 版本引入的重要特性之一, 对于集合（例如 List、Map、Set 等）进行处理和操作的高级抽象.Stream API 提供了一种更为简洁高效的的方式来处理集合数据, 可读性较高, 特别在数据的过滤、转换、聚合时的操作很简单方便快捷.

##### 1.1 特点与优势 #####

*  **函数式风格**: Stream API使用函数式接口和Lambda表达式, 让代码更具表达力和简洁性.
 *  **惰性求值**: Stream操作通常是惰性求值的, 这意味着在终端操作之前, 中间操作不会立即执行, 从而提高了效率.
 *  **并行处理**: 通过Stream API可以方便地实现并行处理, 从而充分利用多核处理器的优势, 加速处理大量数据的过程.

下面根据一些实际应用场景来分析

##### 1.2 两大类型 #####

*  中间操作(Intermediate Operations):中间操作是指在Stream上执行的操作, 它们返回一个新的Stream, 允许你链式地进行多个中间操作.
 *  终端操作(Terminal Operations):对Stream进行最终处理的操作, 当调用终端操作时, Stream会开始执行中间操作, 并生成最终的结果或副作用.终端操作是Stream的"触发器", 一旦调用终端操作, Stream就不能再被使用, 也不能再进行中间操作.

#### 2.Stream API 中间操作 ####

##### 2.1 filter(条件) #####

用于根据指定条件过滤元素.它接收一个条件作为参数, 只保留满足条件的元素, 并生成一个新的Stream.  
示例:  
**存在一个姓名的集合，现在要过滤出来名字中带【大】的人员.**

public static void main(String[] args) {
        
    	List<String> tempList = Arrays.asList("刘一手", "杜子腾", "林大蛋", "Ekko");
    	List<String> resList = tempList.stream()
    	        .filter(s -> s.contains("大"))
    	        .collect(Collectors.toList());
    	System.out.println(resList.toString());
    }

输出:

[林大蛋]

> 这段Java代码展示了如何使用Java Stream API对一个字符串列表进行处理，并筛选出包含字符"大"的字符串，然后将筛选后的结果收集到一个新的列表中，最后输出结果。  
> 让我们逐步解释这段代码：  
> 首先我们创建了一个包含四个字符串的集合，后使用 Stream API 对 tempList 进行处理。  
> 首先，通过调用stream()方法，将tempList转换为一个Stream。  
> 接着，使用filter中间操作筛选出包含字符"大"的字符串。  
> 这里的filter方法接收一个Lambda表达式作为参数，Lambda 表达式 `s -> s.contains("大")`用于判断字符串是否包含字符"大"。  
> 只有满足条件的字符串会被保留在Stream中。  
> collect(Collectors.toList())这部分是终端操作，它将Stream中的元素收集到一个新的列表中。在这里，我们使用Collectors.toList()方法来将Stream中的筛选结果收集到一个新的List中，赋值给resList。

##### 2.2 map(函数) #####

用于对每个元素执行映射操作, 将元素转换成另一种类型.它接收一个Function（映射函数）作为参数, 对每个元素应用该映射函数, 并生成一个新的Stream.  
示例:  
**存在一个姓名的集合，现在要给所有名字加上姓名的前缀.**

public static void main(String[] args) {
        
    	List<String> tempList = Arrays.asList("刘一手", "杜子腾", "林大蛋", "Ekko");
    	List<String> resList = tempList.stream()
    	        .map(s -> "姓名: " + s)
    	        .collect(Collectors.toList());
    	System.out.println(resList.toString());
    }

输出:

[姓名: 刘一手, 姓名: 杜子腾, 姓名: 林大蛋, 姓名: Ekko]

> 这段代码的意思是创建一个姓名集合，通过stream()方法把集合转换为 Stream 流,通过 map() 方法给每个集合中的值拼接字符串后,使用collect()方法把这些元素归集到一个新的 List 集合并赋值给 resList.
> 
> 这里的 `.map(s -> "姓名: " + s)`是简写,详细的更容易理解的写法如下:
> 
> .map(s -> \{  
> return "姓名: " + s;  
> \})

##### 2.3 flatMap(函数) #####

类似于map操作，但是 flatMap 操作可以将每个元素映射成一个 Stream，然后把所有生成的 Stream 合并成一个新的Stream。

示例:

**新建一个静态内部类, 然后聚合类中的集合数据**

@Data
    static class Personnel {
        
        // 人员姓名
        private String name;
        // 人员标签
        private List<String> tagList;
    
        public Personnel(String name, List<String> tagList) {
        
            this.name = name;
            this.tagList = tagList;
        }
    }

Tips: 就现在想要把 `List<Personnel>` 中的 `tagList` 聚合后进行处理, 代码如下:

public static void main(String[] args) {
        
        Personnel personA = new Personnel("张三", Arrays.asList("抽烟", "喝酒", "烫头"));
        Personnel personB = new Personnel("李斯", Arrays.asList("编码", "喝酒", "踢足球"));
        List<Personnel> personnelList = Arrays.asList(personA, personB);
        personnelList.stream()
                .flatMap(p -> p.getTagList().stream())
                .forEach(s -> System.out.print(s + " "));
    }

输出:

抽烟 喝酒 烫头 编码 喝酒 踢足球

##### 2.4 sorted() #####

用于对Stream中的元素进行排序，默认按照自然顺序进行排序。也可以传入自定义的Comparator来指定排序规则。

示例：

public class SortedTest {
        
        public static void main(String[] args) {
        
            List<Integer> numList = Arrays.asList(10, 20, 18, 300, 30, 2);
            // ① 默认排序
            List<Integer> orderList = numList.stream()
                    .sorted()
                    .collect(Collectors.toList());
            System.out.printf("① 默认排序: %s%n", orderList);
            // ② 自定义排序
            List<Integer> orderDescList = numList.stream()
                    .sorted((x, y) -> {
        
                        return y.compareTo(x);
                    })
                    .collect(Collectors.toList());
            System.out.printf("② 自定义排序: %s%n", orderDescList);
        }
    }

输出：

① 默认排序: [2, 10, 18, 20, 30, 300]
    ② 自定义排序: [300, 30, 20, 18, 10, 2]

> 关于 `return y.compareTo(x);` 这块的具体意义，可以自行搜索 `compareTo` 方法了解下，这里不做单独赘述

##### 2.5 distinct() #####

用于去除 Stream 中重复的元素，确保最终的 Stream 中每个元素都是唯一的。

示例：

public class DistinctStreamTest {
        
        public static void main(String[] args) {
        
            List<Integer> numList = Arrays.asList(1,1,1,1,2,3,2,2);
            List<Integer> distinctList = numList.stream()
                    .distinct()
                    .collect(Collectors.toList());
            System.out.println(distinctList);
        }
    }

输出：

[1, 2, 3]

> 这段代码先创建了一个数字集合，接下来使用 stream() 方法转化为 Stream 流  
> 使用 distinct() 方法对流中的元素进行去重，返回一个不包含重复元素的Stream 流  
> 最后使用 collect() 方法对去重后的流转换成一个新的 List 集合。

##### 2.6 limit(long n) #####

用于限制Stream的大小，返回一个最大包含前n个元素的新Stream。

示例：

public class LimitStreamTest {
        
        public static void main(String[] args) {
        
            List<Integer> numList = Arrays.asList(1,2,3,4,5,6,7,8);
            List<Integer> limitList = numList.stream()
                    .limit(4)
                    .collect(Collectors.toList());
            System.out.println(limitList);
        }
    }

这段代码创建一个包含整数的List集合`numList`，使用Stream API的`limit(4)`方法将集合截取为只包含前4个元素的新List集合，并将结果输出到控制台。

输出结果为：\[1, 2, 3, 4\]

##### 2.7 skip(long n) #####

用于跳过Stream中的前n个元素，返回一个丢弃了前n个元素后剩余元素的新Stream。

示例：

public class SkipStreamTest {
        
        public static void main(String[] args) {
        
            List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
            List<Integer> skipList = numList.stream()
                    .skip(numList.size() - 2)
                    .collect(Collectors.toList());
            System.out.println(skipList);
        }
    }

这段代码创建一个包含整数的List集合`numList`，使用Stream API的 `skip` 方法将集合截取跳过前 `集合大小-2`个元素的新List集合，并将结果输出到控制台。

输出结果为：\[7, 8\]

##### 2.8 peek(Consumer) #####

用于对每个元素执行一个操作，同时保持Stream的流。它可以用于调试或记录Stream中的元素。

示例：

public class PeekStreamTest {
        
        public static void main(String[] args) {
        
            List<Integer> numList = Arrays.asList(5, 6, 7, 8);
            List<Integer> resList = numList.stream()
                    .peek(System.out::println)
                    .filter(s -> s == 5)
                    .peek(s -> System.out.printf("过滤后的:%d%n", s))
                    .collect(Collectors.toList());
        }
    }

输出:

5
    过滤后的:5
    6
    7
    8

这段代码创建一个包含整数的List集合`numList`，使用Stream API的 `peek` 方法记录初始的值，通过中间操作 filter 方法过滤值为 5 的后，再次通过peek 方法来打印并验证我们的表达式后，把过滤后的结果通过 collect 方法生成一个新的 List 集合。

#### 3.终端操作 ####

在Java Stream API中，终端操作（Terminal Operations）是对Stream进行最终处理的操作。当调用终端操作时，Stream会开始执行中间操作，并生成最终的结果或副作用。终端操作是Stream的`触发器`，一旦调用终端操作，Stream就不能再被使用，也不能再进行中间操作。

以下是一些常见的Stream API终端操作：

##### 3.1 forEach(Consumer) #####

对Stream中的每个元素执行指定的操作，接收一个Consumer（消费者函数）作为参数。它通常用于对Stream中的元素进行输出或执行某些操作，但不会返回任何结果。

示例: **遍历输出中间操作后的集合**

public class ForEachStreamTest {
        
        public static void main(String[] args) {
        
            // 给公司工资普涨 500
            List<Integer> salaryList = Arrays.asList(12000, 20000, 30000, 4000);
            salaryList.stream()
                    .peek(s -> System.out.print("工资普涨前:" + s))
                    .map(s -> s + 500)
                    .forEach(s -> {
        
                        System.out.println("--工资普涨后:" + s);
                    });
        }
    }

> 以上代码的含义是,创建一个工资集合,通过 stream() 方法转换为 Stream 流,通过中间操作 peek() 方法记录转换前的元素值,后通过 map() 方法给元素进行转换操作,最后通过终端操作 forEach() 方法进行遍历.

输出:

工资普涨前:12000--工资普涨后:12500
    工资普涨前:20000--工资普涨后:20500
    工资普涨前:30000--工资普涨后:30500
    工资普涨前:4000--工资普涨后:4500

##### 3.2 collect(Collector) #####

用于将Stream中的元素收集到一个容器中，接收一个Collector（收集器）作为参数。它允许你在Stream中执行各种集合操作，例如将元素收集到List、Set、Map等容器中。

示例: **把 User 实体集合转换为 Map 集合,名字作为 key,工资作为 Name**

public class CollectStreamTest {
        
        public static void main(String[] args) {
        
            List<User> userList = Arrays.asList(new User("张三", 2000.5),
                    new User("李斯", 11000.5),
                    new User("王二", 12000.5),
                    new User("张六", 32000.5),
                    new User("赵公子", 1000000.0));
            Map<String, Double> userSalaryMap = userList.stream()
                    .collect(Collectors.toMap(User::getName, User::getSalary));
            userSalaryMap.forEach((k, v) -> {
        
                System.out.printf("姓名:%s,工资:%.2f%n", k, v);
            });
        }
    
        @Data
        @AllArgsConstructor
        static class User {
        
            private String name;
            private Double salary;
        }
    }

> 上述代码的含义是创建一个人员集合,通过 stream() 转换为 Stream 流,使用 collect() 方法把元素归集, 利用 Collectors.toMap() 收集器转换为 Map 后,内部接收会遍历每个元素,`Collectors.toMap(User::getName, User::getSalary)`是简写,详细的写法如下:
> 
> Collectors.toMap(s -> s.getName(), s -> s.getSalary())

输出:

姓名:张三,工资:2000.50
    姓名:赵公子,工资:1000000.00
    姓名:张六,工资:32000.50
    姓名:李斯,工资:11000.50
    姓名:王二,工资:12000.50

##### 3.3 toArray() #####

将Stream中的元素转换成一个数组。返回一个包含所有元素的数组，返回的数组类型是根据流元素的类型自动推断的。如果流是空的，将返回一个长度为0的数组。

示例:

public class ToArrayStreamTest {
        
        public static void main(String[] args) {
        
            // 示例整数流
            IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
    
            // 使用toArray()将流中的元素收集到一个数组中
            int[] intArray = intStream.toArray();
            
            // 输出结果数组
            System.out.println(Arrays.toString(intArray));
        }
    }

输出:

[1, 2, 3, 4, 5]

> 在这个示例中，我们创建了一个整数流 `IntStream`，然后使用 `toArray()` 方法将流中的所有整数收集到一个数组中，并输出结果数组。

##### 3.4 reduce(BinaryOperator) #####

`Stream` 类的 `reduce()` 方法是用于将流中的元素进行归约操作的方法。接收一个 `BinaryOperator（二元运算函数`作为参数，用于对两个元素进行操作，并返回一个合并后的结果。它可以将流中的所有元素按照指定的规则进行合并，并返回一个 `Optional` 对象，因为流可能为空。

示例:

public class ReduceStreamTest {
        
        public static void main(String[] args) {
        
            // 示例整数流
            IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
    
            // 使用reduce()将流中的整数相加得到总和
            OptionalInt sumOptional = intStream.reduce((a, b) -> a + b);
    
            // 获取结果总和，如果流为空，则给出一个默认值0
            int sum = sumOptional.orElse(0);
    
            // 输出结果总和
            System.out.println("总和: " + sum);
        }
    }

输出:

总和: 15

> 上面的代码中，我们创建了一个整数流 `IntStream`，然后使用 `reduce()` 方法将流中的整数相加得到总和。由于流中有元素，因此 `reduce()` 方法返回包含总和的 `Optional` 对象。我们使用 `orElse(0)` 获取结果总和，防止流为空的情况。最后输出得到的结果总和。

##### 3.5 min(Comparator) / max(Comparator) #####

`Stream` 类的 `min()` 和 `max()` 方法是用于查找流中的最小值和最大值的终端操作。它们接受一个 `Comparator` 对象作为参数来确定元素的顺序，并返回一个 `Optional` 对象，因为流可能为空。

以下是 `min()` 和 `max()` 方法的简要解释以及示例代码：

**`min()` 方法：**

Optional<T> min(Comparator<? super T> comparator)

*  方法签名：`<T> Optional<T> min(Comparator<? super T> comparator)`
 *  `min()` 方法用于查找流中的最小元素。
 *  `comparator` 参数用于确定元素的顺序，以便找到最小值。
 *  如果流为空，则返回一个空的 `Optional` 对象。

**`max()` 方法：**

Optional<T> max(Comparator<? super T> comparator)

*  方法签名：`<T> Optional<T> max(Comparator<? super T> comparator)`
 *  `max()` 方法用于查找流中的最大元素。
 *  `comparator` 参数用于确定元素的顺序，以便找到最大值。
 *  如果流为空，则返回一个空的 `Optional` 对象。

示例：**假设我们有一个包含整数的流，并且我们想找到其中的最小值和最大值**

public class MinMaxStreamTest {
        
        public static void main(String[] args) {
        
            // 示例整数流
            Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用min()找到最小值
            Optional<Integer> minOptional = integerStream.min(Integer::compareTo);
            if (minOptional.isPresent()) {
        
                System.out.println("最小值为: " + minOptional.get());
            } else {
        
                System.out.println("流为空.");
            }
    
            // 重新创建一个整数流，因为流已被消耗
            Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用max()找到最大值
            Optional<Integer> maxOptional = newIntegerStream.max(Integer::compareTo);
            if (maxOptional.isPresent()) {
        
                System.out.println("最大值为: " + maxOptional.get());
            } else {
        
                System.out.println("流为空.");
            }
        }
    }

输出:

最小值为: 1
    最大值为: 8

> 上述代码中，我们创建了一个整数流 `Stream<Integer>`，然后使用 `min()` 方法找到最小值，并使用 `max()` 方法找到最大值。我们使用 `Optional` 对象来处理可能为空的情况，并输出找到的最小值和最大值。请注意，一旦流被消耗，就不能再次使用它，因此我们在找到最小值后重新创建了一个整数流来找到最大值。

##### 3.6 count() #####

`Stream` 类的 `count()` 方法是用于计算流中元素个数的终端操作。它返回一个 `long` 类型的值，表示流中的元素数量。`count()` 方法是一个终端操作，一旦调用该方法，流就被消耗，无法再次使用。

示例: **有一个包含整数的流，并且我们想计算流中的元素个数**

public class CountStreamTest {
        
        public static void main(String[] args) {
        
            // 示例整数流
            Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用count()计算流中的元素个数
            long count = integerStream.count();
    
            // 输出元素个数
            System.out.println("元素数量: " + count);
        }
    }

输出:

元素数量: 5

> 上述代码中，我们创建了一个整数流 `Stream<Integer>`，然后使用 `count()` 方法计算流中的元素个数。由于这是一个终端操作，一旦调用了 `count()` 方法，流就会被消耗，不能再次使用。我们输出计算得到的元素个数。

##### 3.7 anyMatch(Predicate) / allMatch(Predicate) / noneMatch(Predicate) #####

`Stream` 类的 `anyMatch()`, `allMatch()`, 和 `noneMatch()` 是用于检查流中元素是否满足特定条件的终端操作。它们返回一个布尔值，表示流中的元素是否满足指定的条件。这些方法在遇到满足条件的元素后可能会提前终止流的处理。anyMatch检查是否有任意元素满足条件，allMatch检查是否所有元素都满足条件，noneMatch检查是否没有元素满足条件。

以下是 `anyMatch()`, `allMatch()`, 和 `noneMatch()` 方法的简要解释以及示例代码：

**`anyMatch()` 方法：**

boolean anyMatch(Predicate<? super T> predicate)

*  方法签名：`boolean anyMatch(Predicate<? super T> predicate)`
 *  `anyMatch()` 方法用于检查流中是否存在至少一个元素满足给定的条件。
 *  它接受一个 `Predicate` 参数，用于定义满足条件的判断规则。
 *  如果流中至少有一个元素满足条件，返回 `true`，否则返回 `false`。

**`allMatch()` 方法：**

boolean allMatch(Predicate<? super T> predicate)

*  方法签名：`boolean allMatch(Predicate<? super T> predicate)`
 *  `allMatch()` 方法用于检查流中的所有元素是否都满足给定的条件。
 *  它接受一个 `Predicate` 参数，用于定义满足条件的判断规则。
 *  如果流中的所有元素都满足条件，返回 `true`，否则返回 `false`。

**`noneMatch()` 方法：**

boolean noneMatch(Predicate<? super T> predicate)

*  方法签名：`boolean noneMatch(Predicate<? super T> predicate)`
 *  `noneMatch()` 方法用于检查流中是否所有元素都不满足给定的条件。
 *  它接受一个 `Predicate` 参数，用于定义满足条件的判断规则。
 *  如果流中的所有元素都不满足条件，返回 `true`，否则返回 `false`。

**示例代码：**

假设我们有一个包含整数的流，并且我们想检查流中是否存在某些元素满足特定条件。

public class MatchStreamTest {
        
    
        public static void main(String[] args) {
        
            // 示例整数流
            Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用anyMatch()检查是否存在元素大于5
            boolean anyGreaterThan5 = integerStream.anyMatch(num -> num > 4);
            System.out.println("是否存在元素大于 5 ?" + anyGreaterThan5);
    
            // 重新创建一个整数流，因为流已被消耗
            Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用allMatch()检查是否所有元素都小于10
            boolean allLessThan10 = newIntegerStream.allMatch(num -> num < 10);
            System.out.println("所有元素都小于10 ? " + allLessThan10);
    
            // 重新创建一个整数流，因为流已被消耗
            Stream<Integer> newestIntegerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用noneMatch()检查是否没有元素等于10
            boolean noneEqualTo10 = newestIntegerStream.noneMatch(num -> num == 10);
            System.out.println("是否没有元素等于 10 ? " + noneEqualTo10);
        }
    }

输出：

是否存在元素大于 5 ?true
    所有元素都小于10? true
    是否没有元素等于 10 ? true

> 上述代码中，我们创建了一个整数流 `Stream<Integer>`，然后使用 `anyMatch()` 方法检查是否存在元素大于5，使用 `allMatch()` 方法检查是否所有元素都小于10，以及使用 `noneMatch()` 方法检查是否没有元素等于10。我们输出检查的结果。注意，在每次使用终端操作后，流就被消耗了，不能再次使用，因此在检查不同条件时需要重新创建流。

##### 3.8 findFirst() / findAny() #####

`Stream` 类的 `findFirst()` 和 `findAny()` 方法用于在流中查找元素的终端操作。它们都返回一个 `Optional` 对象，表示找到的元素或元素的可能性。在并行流中，`findAny()` 方法可能更快，因为它不一定要遍历所有元素。在串行 `Stream` 中，`findFirst()`和 `findAny()` 返回的是相同的元素，在并行`Stream`中，`findAny()`返回的是最先找到的元素。

以下是 `findFirst()` 和 `findAny()` 方法的简要解释以及示例代码：

**`findFirst()` 方法：**

Optional<T> findFirst()

*  方法签名：`Optional<T> findFirst()`
 *  `findFirst()` 方法用于在流中查找第一个满足条件的元素。
 *  它返回一个 `Optional` 对象，表示找到的元素，如果流为空，则返回一个空的 `Optional` 对象。

**`findAny()` 方法：**

Optional<T> findAny()

*  方法签名：`Optional<T> findAny()`
 *  `findAny()` 方法用于在流中查找任意一个满足条件的元素。
 *  它返回一个 `Optional` 对象，表示找到的元素，如果流为空，则返回一个空的 `Optional` 对象。
 *  在并行流中，`findAny()` 方法可能比 `findFirst()` 方法更快，因为它不一定要遍历所有元素。

**示例代码：**

假设我们有一个包含整数的流，并且我们想查找其中的某个元素。

public class FindStreamTest {
        
        public static void main(String[] args) {
        
            // 示例整数流
            Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用findFirst()找到第一个元素
            Optional<Integer> firstElementOptional = integerStream.findFirst();
            if (firstElementOptional.isPresent()) {
        
                System.out.println("发现第一个元素: " + firstElementOptional.get());
            } else {
        
                System.out.println("流为空!");
            }
    
            // 重新创建一个整数流，因为流已被消耗
            Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);
    
            // 使用findAny()找到任意一个元素
            Optional<Integer> anyElementOptional = newIntegerStream.findAny();
            if (anyElementOptional.isPresent()) {
        
                System.out.println("找到任意一个元素: " + anyElementOptional.get());
            } else {
        
                System.out.println("流为空!");
            }
        }
    }

输出（注意输出的结果可能因为流的处理顺序不同而有所变化）：

发现第一个元素: 1
    找到任意一个元素: 1

> 上述代码中，创建了整数流 `Stream<Integer>`，然后使用 `findFirst()` 方法找到第一个元素，使用 `findAny()` 方法找到任意一个元素，并输出找到的元素。请注意，一旦调用了这些方法，流就被消耗了，不能再次使用。在并行流中，`findAny()` 方法可能比 `findFirst()` 方法更快，因为它不一定要遍历所有元素。