最全的JavaStream操作集合教程

什么是JavaStream?

• Java Stream是Java 8中引入的一种新的流式编程API，它可以让开发者以一种更简洁、更优雅的方式对数据集合进行操作和处理。Java Stream提供了一种流式的、声明式的方式来处理数据，让代码更易读、更易维护，并且可以自动进行并行处理，提高了代码的执行效率。
• Java Stream可以对集合、数组、I/O等数据进行操作，常见的操作包括过滤、映射、排序、归约等。使用Java Stream，开发者可以通过链式调用的方式组合多个操作，从而实现复杂的数据处理逻辑。此外，Java Stream还支持并行处理数据，可以通过parallel()方法将顺序流转换为并行流，从而充分利用多核CPU的性能优势。
• 总的来说，Java Stream的作用在于提供了一种更加简洁、高效的数据处理方式，使得代码更易读、易维护，并且能够充分利用多核CPU的性能，提高代码的执行效率。

常用的StreamAPI有哪些?

1. filter(Predicate predicate)：根据给定的条件过滤元素。
2. map(Function<T, R> mapper)：将每个元素转换为另一个元素
3. flatMap(Function<T, Stream> mapper)：将每个元素转换为一个流，并将所有流合并为一个流。
4. distinct()：去重，去掉重复的元素。
5. sorted()：排序，将元素排序。
6. limit(long maxSize)：截取前面的元素。
7. skip(long n)：跳过前面的元素。
8. forEach(Consumer action)：对每个元素执行给定的操作。
9. toArray(IntFunction<A[]> generator)：将流中的元素转换为一个数组。
10. reduce(T identity, BinaryOperator accumulator)：使用给定的初始值和累加器将流中的元素合并为一个值。
11. collect(Collector<T, A, R> collector)：将流中的元素收集到一个可变的容器中，如 List、Set、Map 等。
12. anyMatch(Predicate predicate)：检查是否有至少一个元素符合给定的条件。
13. allMatch(Predicate predicate)：检查是否所有元素都符合给定的条件。
14. noneMatch(Predicate predicate)：检查是否没有任何元素符合给定的条件。
15. findFirst()：返回第一个元素。
16. findAny()：返回任意一个元素。
17. max(Comparator comparator)：返回流中的最大值。
18. min(Comparator comparator)：返回流中的最小值。
19. count()：返回流中元素的总数。
20. parallel()：将流转换为并行流，以便进行并行处理。
21. sequential()：将流转换为顺序流，以便进行顺序处理。
22. forEachOrdered(Consumer action)：对流中的每个元素执行操作，但是保证顺序。

常用的StreamAPI代码使用示例

1.filter根据给定的条件过滤元素

Predicate 接口有一个抽象方法 test(T t)，它接受一个类型为 T 的参数，返回一个布尔值。

String[] words = {"apple", "banana", "cherry", "date", "elderberry"};
Stream<String> stream = Arrays.stream(words);

// 过滤出长度大于 5 的字符串
Stream<String> filteredStream = stream.filter(s -> s.length() > 5);

// 输出过滤后的字符串
filteredStream.forEach(System.out::println); 
// 输出：banana cherry elderberry

2.map将每个元素转换为另一个元素

Function 接口有一个抽象方法 apply(T t)，它接受一个类型为 T 的参数，返回一个类型为 R 的结果。

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

// 将每个数乘以 2
IntStream mappedStream = stream.map(n -> n * 2);

// 输出乘以 2 后的结果
mappedStream.forEach(System.out::println); 
// 输出：2 4 6 8 10

3.flatMap将每个元素转换为一个流，并将所有流合并为一个流

String[] lines = {"Hello World", "Java 8 is awesome"};
Stream<String> stream = Arrays.stream(lines);

// 将每个字符串转换成一个单词流，然后合并成一个流
Stream<String> flatMappedStream = stream.flatMap(line -> Arrays.stream(line.split(" ")));

// 输出所有单词
flatMappedStream.forEach(System.out::println); 
// 输出：Hello World Java 8 is awesome

4.distinct去重，去掉重复的元素

String[] words = {"apple", "banana", "cherry", "apple", "date", "banana", "elderberry"};
Stream<String> stream = Arrays.stream(words);

// 去掉重复的字符串
Stream<String> distinctStream = stream.distinct();

// 输出去重后的字符串
distinctStream.forEach(System.out::println); // 输出：apple banana cherry date elderberry

5.sorted排序，将元素排序。

int[] nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
IntStream stream = Arrays.stream(nums);

// 对整数数组进行排序
IntStream sortedStream = stream.sorted();

// 输出排序后的结果
sortedStream.forEach(System.out::println); // 输出：1 1 2 3 3 4 5 5 5 6 9

6.limit截取前面的元素。

int[] nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
IntStream stream = Arrays.stream(nums);

// 使用 limit 方法限制最多输出 5 个元素
IntStream limitStream = stream.limit(5);

// 输出限制后的结果
limitStream.forEach(System.out::println); // 输出：3 1 4 1 5

7.toArray将流中的元素转换为一个数组

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 66, 234, 123);
IntStream stream = integers.stream().mapToInt(Integer::intValue);

// 将 IntStream 中的元素转换为一个 int 数组
int[] result = stream.toArray();

// 输出转换后的结果
System.out.println(Arrays.toString(result)); // 输出：[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

8.reduce使用给定的初始值和累加器将流中的元素合并为一个值

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

// 使用 reduce 方法求和
int sum = stream.reduce(15, (a, b) -> a + b);

// 输出求和的结果
System.out.println(sum); // 输出：15

9.collect将流中的元素收集到一个可变的容器中，如 List、Set、Map

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

// 使用 collect 方法将 IntStream 中的元素收集到一个 List 中
List<Integer> list = stream.boxed().collect(Collectors.toList());

// 输出收集后的结果
System.out.println(list); // 输出：[1, 2, 3, 4, 5]

10.anyMatch检查是否有至少一个元素符合给定的条件

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

// 使用 anyMatch 方法判断是否有任意一个元素小于 3
boolean result = stream.anyMatch(n -> n < 3);

// 输出判断结果
System.out.println(result); // 输出：true

findAny从Stream中取任意一个元素，正常情况下一般会取第一个元素

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

// 使用 findAny 方法随机返回一个元素
OptionalInt result = stream.findAny();

// 输出随机返回的结果
if (result.isPresent()) {
    System.out.println(result.getAsInt()); // 输出：随机的一个元素，例如 1
} else {
    System.out.println("Stream 流为空");
}

Stream组合操作演示

String[] words = {"apple", "banana", "cherry", "apple", "banana", "banana", "cherry", "cherry", "cherry"};

Map<String, Long> countMap = Arrays.stream(words)
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

List<Map.Entry<String, Long>> countList = new ArrayList<>(countMap.entrySet());
countList.sort(Map.Entry.<String, Long>comparingByValue().reversed());

System.out.println(countList);
// [cherry=4, banana=3, apple=2]