Stream API中有哪些常用中间操作

在Java的Stream API中，有许多常用的中间操作（Intermediate Operations），这些操作可以对流中的元素进行过滤、映射、排序等处理。以下是一些常用的中间操作：

1. filter(Predicate<? super T> predicate)

• 功能：根据给定的谓词（条件）过滤流中的元素。
• 示例：

  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
  List<Integer> evenNumbers = numbers.stream()
                                      .filter(n -> n % 2 == 0)
                                      .collect(Collectors.toList());
  

2. map(Function<? super T, ? extends R> mapper)

• 功能：将流中的每个元素应用一个函数，生成一个新的流。
• 示例：

  List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
  List<Integer> nameLengths = names.stream()
                                   .map(String::length)
                                   .collect(Collectors.toList());
  

3. sorted(Comparator<? super T> comparator)

• 功能：根据给定的比较器对流中的元素进行排序。
• 示例：

  List<Person> people = Arrays.asList(new Person("Alice", 30), new Person("Bob", 25));
  List<Person> sortedPeople = people.stream()
                                    .sorted(Comparator.comparing(Person::getAge))
                                    .collect(Collectors.toList());
  

4. distinct()

• 功能：去除流中的重复元素。
• 示例：

  List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
  List<Integer> distinctNumbers = numbers.stream()
                                        .distinct()
                                        .collect(Collectors.toList());
  

5. limit(long maxSize)

• 功能：截取流的前N个元素。
• 示例：

  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
  List<Integer> firstThreeNumbers = numbers.stream()
                                           .limit(3)
                                           .collect(Collectors.toList());
  

6. skip(long n)

• 功能：跳过流中的前N个元素。
• 示例：

  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
  List<Integer> remainingNumbers = numbers.stream()
                                         .skip(2)
                                         .collect(Collectors.toList());
  

7. flatMap(Function<? super T, Stream<? extends R>> mapper)

• 功能：将流中的每个元素映射为一个流，然后将所有这些流合并成一个单一的流。
• 示例：

  List<List<Integer>> listOfLists = Arrays.asList(
      Arrays.asList(1, 2, 3),
      Arrays.asList(4, 5),
      Arrays.asList(6)
  );
  List<Integer> flatList = listOfLists.stream()
                                       .flatMap(List::stream)
                                       .collect(Collectors.toList());
  

8. peek(Consumer<? super T> action)

• 功能：对流中的每个元素执行一个操作，通常用于调试或副作用。
• 示例：

  List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
  List<String> upperCaseNames = names.stream()
                                     .peek(name -> System.out.println("Processing: " + name))
                                     .map(String::toUpperCase)
                                     .collect(Collectors.toList());
  

9. anyMatch(Predicate<? super T> predicate)

• 功能：检查流中是否有任何元素满足给定的谓词。
• 示例：

  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
  boolean hasEvenNumber = numbers.stream()
                                .anyMatch(n -> n % 2 == 0);
  

10. allMatch(Predicate<? super T> predicate)

• 功能：检查流中的所有元素是否都满足给定的谓词。
• 示例：

  List<Integer> numbers = Arrays.asList(2, 4, 6, 8);
  boolean allEvenNumbers = numbers.stream()
                                  .allMatch(n -> n % 2 == 0);
  

这些中间操作可以组合使用，以实现复杂的流处理逻辑。