Java流式方法，详细版本。

概要

流（Stream）是Java 8引入的一项重要特性，它允许以一种更加简洁、函数式的方式对数据集合进行操作。流可以看作是一系列元素的序列，支持各种操作，包括过滤、映射、排序、归约等。总体上分为中间操作和终端操作两种类型

1. 中间操作

1.1 filter(Predicate)

作用：过滤流中的元素，根据给定的谓词（Predicate）判断，只保留符合条件的元素。
例子:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());
System.out.println(evenNumbers);  // 输出：[2, 4]

1.2 map(Function)

作用：将流中的每个元素都映射到另一个元素，返回一个新的流。
例子:

List<String> words = Arrays.asList("apple", "banana", "cherry");
List<Integer> wordLengths = words.stream()
                                .map(String::length)
                                .collect(Collectors.toList());
System.out.println(wordLengths);  // 输出：[5, 6, 6]

1.3 flatMap(Function)

作用：将流中的每个元素映射为一个流，并将这些流合并为一个流。
例子:

List<List<Integer>> nestedLists = Arrays.asList(
        Arrays.asList(1, 2, 3),
        Arrays.asList(4, 5, 6),
        Arrays.asList(7, 8, 9)
);

List<Integer> flattenedList = nestedLists.stream()
                                        .flatMap(List::stream)
                                        .collect(Collectors.toList());
System.out.println(flattenedList);  // 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

1.4 distinct()

作用：去除流中重复的元素。
例子:

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);
List<Integer> distinctNumbers = numbers.stream()
                                      .distinct()
                                      .collect(Collectors.toList());
System.out.println(distinctNumbers);  // 输出：[1, 2, 3, 4]

1.5 sorted(Comparator)

作用：对流中的元素进行排序，可以通过传递一个Comparator来指定排序规则。
例子:

List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
List<Integer> sortedNumbers = numbers.stream()
                                    .sorted()
                                    .collect(Collectors.toList());
System.out.println(sortedNumbers);  // 输出：[1, 2, 3, 4, 5]

1.6 limit(long)

作用：限制流的大小，保留前N个元素。
例子:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limitedNumbers = numbers.stream()
                                     .limit(3)
                                     .collect(Collectors.toList());
System.out.println(limitedNumbers);  // 输出：[1, 2, 3]

1.7 skip(long)

作用：跳过流的前N个元素。
例子:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skippedNumbers = numbers.stream()
                                     .skip(2)
                                     .collect(Collectors.toList());
System.out.println(skippedNumbers);  // 输出：[3, 4, 5]

2. 终端操作

2.1 forEach(Consumer)

作用：对流中的每个元素执行一个操作。
例子:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream().forEach(System.out::println);
// 输出：
// Alice
// Bob
// Charlie

2.2 collect(Collector)

作用：将流中的元素收集到一个集合或其他容器中。
例子:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> collectedNumbers = numbers.stream()
                                       .collect(Collectors.toList());
System.out.println(collectedNumbers);  // 输出：[1, 2, 3, 4, 5]

2.3 count()

作用：返回流中的元素个数。
例子:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream().count();
System.out.println(count);  // 输出：5

2.4 reduce(BinaryOperator)

作用：对流的元素进行归约操作，返回一个Optional对象。
例子:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream()
                               .reduce((a, b) -> a + b);
sum.ifPresent(result -> System.out.println("Sum: " + result));  // 输出：Sum: 15

2.5 max(Comparator)

作用：返回流中的最大元素。
例子:

List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
Optional<Integer> maxNumber = numbers.stream()
                                     .max(Comparator.naturalOrder());
maxNumber.ifPresent(max -> System.out.println("Max number: " + max));  // 输出：Max number: 5

2.6 min(Comparator)

作用：返回流中的最小元素。
例子:

List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
Optional<Integer> minNumber = numbers.stream()
                                     .min(Comparator.naturalOrder());
minNumber.ifPresent(min -> System.out.println("Min number: " + min));  // 输出：Min number: 1