java基础之stream流实战

Stream API 可以分为以下几个主要类别：

1. 创建流（Creating Streams）：
   • Stream.of(T... values)：从一个变量参数创建流。
   • Arrays.stream(T[] array)：从数组创建流。
   • Collection.stream()：从集合创建流。
   • Stream.iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)：创建一个无限的流，从一个初始值开始，每次应用一个函数。
   • Stream.generate(Supplier<T> s)：创建一个无限的流，每次从给定的 Supplier 获取值。
2. 中间操作（Intermediate Operations）：
   • 无状态（Stateless）：filter, map, flatMap, peek, limit, sorted 等。
   • 有状态（Stateful）：distinct, sorted（有状态，因为它需要跟踪元素以维护排序顺序）。
3. 终止操作（Terminal Operations）：
   • 聚合操作：reduce, collect, allMatch, anyMatch, noneMatch, count, forEach 等。
   • 规约/求值操作：forEach, toArray, reduce, collect 等。
   • 短路操作：anyMatch, allMatch, noneMatch, findFirst, findAny。
4. 并行操作（Parallel Operations）：
   • 任何流都可以被并行化，通过调用 parallelStream() 方法。
   • 并行流是优化的，可以在多核处理器上并行执行操作。
5. 收集器（Collectors）：
   • Collectors 类提供了很多静态方法，用于在终止操作中将流转换为不同类型的结果，如集合、数组或复合对象。
   • 常用的收集器包括 toList(), toSet(), toMap(), joining(), groupingBy(), reducing() 等。
6. 短路操作（Short-circuiting Operations）：
   • 这些操作在找到第一个匹配元素时就会停止处理流，如 anyMatch, allMatch, noneMatch, findFirst, findAny。
7. 非短路操作（Non-Short-circuiting Operations）：
   • 这些操作会处理流中的所有元素，如 allMatch, noneMatch, count, forEach。
8. 无序操作（Unordered Operations）：
   • 某些操作不保证结果的顺序，如 forEach。
9. 有序操作（Ordered Operations）：
   • 某些操作会保持元素的顺序，如 sorted, limit。

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

List<String> words = Arrays.asList("a", "bb", "ccc", "dddd");
List<Integer> lengths = words.stream()
                              .map(String::length)
                              .collect(Collectors.toList());

filter(Predicate<? super T> predicate)：

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

forEach(Consumer<? super T> action)：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> upperCaseNames = new ArrayList<>();
names.stream()
     .forEach(name -> upperCaseNames.add(name.toUpperCase()));

sorted(Comparator<? super T> comparator)：

List<String> words = Arrays.asList("apple", "banana", "cherry");
List<String> sortedWords = words.stream()
                                .sorted()
                                .collect(Collectors.toList());

reduce(BinaryOperator<T> accumulator)：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
 int sum = numbers.stream()
                   .reduce(0, (a, b) -> a + b);

anyMatch(Predicate<? super T> predicate)：

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

allMatch(Predicate<? super T> predicate)：

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

noneMatch(Predicate<? super T> predicate)：

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

findFirst()：

List<String> words = Arrays.asList("apple", "banana", "cherry");
Optional<String> firstWord = words.stream()
                                   .findFirst();

findAny()：

List<String> words = Arrays.asList("apple", "banana", "cherry");
Optional<String> anyWord = words.parallelStream()
                                 .findAny();

collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner)：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                  .collect(()->0,
                           (acc, item) -> acc += item,
                           (acc1, acc2) -> acc1 + acc2);

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

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