Java Stream()流详细用法

1.创建stream()

//1.通过集合创建 Stream：

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

//2.通过数组创建 Stream：

int[] arr = {1, 2, 3, 4};
IntStream stream = Arrays.stream(arr);

//3.通过静态方法创建 Stream：

Stream<String> stream = Stream.of("a", "b", "c");
IntStream stream = IntStream.range(0, 10);  // 生成 0~9 的整数流

2.中间操作（在 Stream 上进行的各种中间变换，例如过滤、映射、排序等）

//1.过滤

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> collect = list.stream().filter(i -> i % 2 == 0).collect(Collectors.toList());  //[2, 4]

//2.映射

List<String> list = Arrays.asList("apple", "banana", "peach");
List<String> collect = list.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());  //[APPLE, BANANA, PEACH]

//3.从小到大排序

List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5);
List<Integer> collect = list.stream().sorted().collect(Collectors.toList());  //[1, 1, 2, 3, 4, 5, 5, 6, 9]

3.终止操作(在 Stream 上进行的最终操作，例如 forEach、reduce、collect 等)

//1.forEach

List<String> list = Arrays.asList("apple", "banana", "peach");
list.stream().forEach(System.out::println);  //apple banana peach

//2.reduce

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, (a, b) -> a + b);  //15

//3.collect

List<String> list = Arrays.asList("apple", "banana", "peach");
List<String> newList = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());  //[apple]

4.anyMatch、allMatch 和 noneMatch

//1.anyMatch：判断流中是否存在至少一个元素满足指定条件。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean result = list.stream().anyMatch(i -> i > 3);   // true

//2.allMatch：判断流中是否所有元素都满足指定条件。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean result = list.stream().allMatch(i -> i > 0);   // true

//3.noneMatch：判断流中是否不存在满足指定条件的元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean result = list.stream().noneMatch(i -> i < 0);   // true

5.findFirst 和 findAny

//1.findFirst：返回流中的第一个元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> optional = list.stream().findFirst();   // Optional[1]

//2.findAny：返回流中任意一个元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> optional = list.stream().filter(i -> i >= 3).findAny();   // Optional[3] 或 Optional[4] 或 Optional[5]

6.reduce

//1.reduce 方法可以将流中所有元素按照某种规则进行计算或合并，返回一个 Optional 对象。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> optional = list.stream().reduce((a, b) -> a + b);   // Optional[15]

//2.接受一个初始值，然后使用二元运算符将初始值和流中的每个元素进行运算，最终返回运算结果。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int result1 = list.stream().reduce(0, (a, b) -> a + b);   // 15

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int result1 = list.stream().reduce(0, Integer::sum);   // 15（第一个参数 0 是初始值，表示当流为空时的默认返回值，Integer::sum 是一个函数接口，表示对两个元素进行操作的规则，这里是求和）

//3.字符串拼接
List<String> list = Arrays.asList("h", "e", "l", "l", "o");
String result2 = list.stream().reduce("", (s1, s2) -> s1 + s2);   // "hello"

7.parallelStream

//parallelStream 方法可以将流转换为并行流，多线程处理流中的元素，加快处理速度。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.parallelStream().mapToInt(Integer::intValue).sum();

8.flatMap

//flatMap 方法可以将多个流合并成一个流，并去重。

List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(2, 3, 4);
List<Integer> list3 = Arrays.asList(3, 4, 5);
List<List<Integer>> lists = Arrays.asList(list1, list2, list3);
List<Integer> result = lists.stream().flatMap(Collection::stream).distinct().collect(Collectors.toList());   // [1, 2, 3, 4, 5]

//这样看起来简洁一些
List<List<Integer>> list = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5, 6));
List<Integer> result = list.stream().flatMap(Collection::stream).collect(Collectors.toList());   // [1, 2, 3, 4, 5, 6]

9.peek

//peek 方法可以在流中的每个元素执行完操作后返回一个新流，而不会改变原来的流。一般用于调试或调用带有副作用的方法。

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.stream()
                          .map(String::toUpperCase)
                          .peek(System.out::println)
                          .collect(Collectors.toList()); //APPLE BANANA CHERRY

10.forEach

//forEach 方法可以对流中的每个元素执行操作，没有返回值。

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.stream().forEach(System.out::println);

11.sorted(对流中的元素进行排序)

//1.默认是自然排序（升序）

List<Integer> list = Arrays.asList(3, 1, 2, 5, 4);
List<Integer> result = list.stream().sorted().collect(Collectors.toList());   // [1, 2, 3, 4, 5]

//2.按照字符串长度排序

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.stream().sorted(Comparator.comparing(String::length)).collect(Collectors.toList());   // ["apple", "cherry", "banana"]

12.collect 和 Collectors

//collect 方法可以将流中的元素收集起来，例如转换为 List、Set、Map 等集合类型。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result1 = list.stream().collect(Collectors.toList());   // [1, 2, 3, 4, 5]
Set<Integer> result2 = list.stream().collect(Collectors.toSet());   // [1, 2, 3, 4, 5]
Map<Integer, String> result3 = list.stream().collect(Collectors.toMap(x -> x, x -> "value" + x));   // {1=value1, 2=value2, 3=value3, 4=value4, 5=value5}

//Collectors 类提供了很多用于集合操作的静态方法，例如 groupingBy、joining、summingInt 等。

13.groupingBy

//1.将流中的元素按照指定条件分组。

List<String> list = Arrays.asList("apple", "banana", "cherry", "pear");
Map<Integer, List<String>> result1 = list.stream().collect(Collectors.groupingBy(String::length));   // {5=[apple, pear], 6=[banana, cherry]}

//2.按照自定义的条件进行分组

Map<String, List<String>> result2 = list.stream().collect(Collectors.groupingBy(s -> s.substring(0, 1)));   // {a=[apple], b=[banana], c=[cherry], p=[pear]}

14.partitioningBy

//将流中的元素按照指定条件分成 true 和 false 两组

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> result = list.stream().collect(Collectors.partitioningBy(x -> x > 3));   // {false=[1, 2, 3], true=[4, 5]}

//2.将结果转换为 Set 类型，并取为true的数据

Set<Integer> result2 = list.stream().collect(Collectors.partitioningBy(x -> x > 3, Collectors.toSet())).get(true);   // [4, 5]

15.toArray

//将流中的元素转换为数组

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Integer[] result = list.stream().toArray(Integer[]::new);   
System.out.print(Arrays.toString(result));   //[1, 2, 3, 4, 5]