java stream流常用方法

filter(Pr edi cat e pr edi cat e)：根据指定条件过滤元素。

List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List&lt;Integer&gt; evenNumbers = numbers.stream()
                                   .filter(n -&gt; n % 2 == 0)
                                   .collect(Collectors.toList());
System.out.println(evenNumbers); // 输出 [2, 4, 6, 8, 10]

map(Function<T, R> mapper)：对每个元素进行映射操作。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());
System.out.println(nameLengths); // 输出 [5, 3, 7]

sorted()：对元素进行排序，默认按照自然顺序进行排序。

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

distinct()：去除重复的元素。

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

limit(long maxSize)：限制元素的数量。

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

skip(long n)：跳过指定数量的元素。

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

forEach(Con sumer action)：对每个元素执行指定操作。

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

reduce(BinaryOperator accumulator)：使用提供的累加器函数对流中的元素进行归约操作，返回一个Optional对象。

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

collect(Collector<? super T, A, R> collector)：将流中的元素收集到一个容器中，如List、Set、Map等。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredNumbers = numbers.stream()
                                      .map(n -> n * n)
                                      .collect(Collectors.toList());
System.out.println(squaredNumbers); // 输出 [1, 4, 9, 16, 25]

anyMatch(Predicate<? super T> pre dicate)：检查流中是否存在满足指定条件的元素，返回一个布尔值。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean hasEvenNumber = numbers.stream()
                               .anyMatch(n -> n % 2 == 0);
System.out.println(hasEvenNumber); // 输出 true

allMatch(Pred icate<? super T> pre d icate)：检查流中的所有元素是否都满足指定条件，返回一个布尔值。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean allGreaterThanZero = numbers.stream()
                                   .allMatch(n -> n > 0);
System.out.println(allGreaterThanZero); // 输出 true

noneMatch(Pred icate<? super T> pre d icate)：检查流中是否没有任何元素满足指定条件，返回一个布尔值。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean noneGreaterThanTen = numbers.stream()
                                    .noneMatch(n -> n > 10);
System.out.println(noneGreaterThanTen); // 输出 true

flatMap(Function<? super T, ? extends Stream<? ext ends R>> mapper)：将流中的每个元素映射为一个流，并将所有流连接成一个流。

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