java stream流常用方法

filter(Predicate predicate)：根据指定条件过滤元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> evenNumbers = numbers.stream().filter(n -> 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(Consumer 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> predicate)：检查流中是否存在满足指定条件的元素，返回一个布尔值。

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(Predicate<? super T> predicate)：检查流中的所有元素是否都满足指定条件，返回一个布尔值。

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

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

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<? extends 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]