一、简介

Java中的Stream是一种用于处理集合元素的工具，它提供了一种流式操作的方式，可以轻松地对集合进行过滤、映射、聚合等操作，以及进行并行处理。以下是关于Java中Stream的详细讲解：

1.1、什么是Stream？

Stream是Java 8引入的一种新的抽象概念，它代表了一种数据元素的序列。
Stream不是数据结构，而是数据元素的流水线，可以进行一系列的操作来处理这些元素。

1.2、创建Stream

可以通过集合类的stream()方法或parallelStream()方法来创建一个流。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();
Stream<Integer> parallelStream = numbers.parallelStream();

1.3、Stream的特性

• 无存储：Stream不是数据结构，它不会在内存中保存数据，而是对源数据进行操作。
• 惰性求值：Stream的操作是延迟执行的，只有在需要结果时才会执行。
• 并行处理：Stream可以并行处理元素，提高处理效率。

二、Stream的操作

2.1、中间操作：

对流进行转换、过滤等操作，并返回一个新的流。中间操作是惰性求值的，只有遇到终端操作时才会执行。

Stream<Integer> filteredStream = stream.filter(x -> x % 2 == 0);
Stream<Integer> mappedStream = stream.map(x -> x * x);

2.2、终端操作：

对流进行最终的处理，并产生一个最终的结果。终端操作会触发中间操作的执行。

long count = stream.count();
Optional<Integer> max = stream.max(Integer::compareTo);
stream.forEach(System.out::println);

2.3、Stream的并行处理

Stream提供了并行处理的能力，可以通过parallel()方法将顺序流转换为并行流，加快处理速度。

Stream<Integer> parallelStream = numbers.parallelStream();

三、Stream 常用函数

流（Stream）类型在Java中提供了许多函数，用于对流进行各种操作和处理。以下是一些常用的流类型函数：

• max :方法找到流中的最大值。

   List<Integer> numbers = Arrays.asList(1, 3, 7, 2, 9, 4, 6);
          
          Optional<Integer> max = numbers.stream()
                                         .max(Integer::compareTo);
          
          if (max.isPresent()) {
              System.out.println("最大值是：" + max.get());
          } else {
              System.out.println("列表为空，没有最大值。");
          }
  

  

• map：对流中的每个元素应用一个函数，并将结果映射到新的流中。

  Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
  Stream<Integer> squaredNumbers = numbers.map(x -> x * x);
  

• forEach：对流中的每个元素执行指定操作。

• filter：根据指定条件过滤流中的元素。

  Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
  Stream<Integer> evenNumbers = numbers.filter(x -> x % 2 == 0);
  

  

• collect：将流中的元素收集到一个集合中。

  Stream<String> words = Stream.of("hello", "world");
  List<String> wordList = words.collect(Collectors.toList());
  

  

• reduce：将流中的元素组合成单个结果。

  Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
  Optional<Integer> sum = numbers.reduce((x, y) -> x + y);
  

  

• flatMap：将多个流合并成一个流。

  List<List<Integer>> listOfLists = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4));
  Stream<Integer> flattenedStream = listOfLists.stream().flatMap(Collection::stream);
  

  

• sorted：对流中的元素进行排序。

  Stream<Integer> numbers = Stream.of(5, 3, 1, 4, 2);
  Stream<Integer> sortedNumbers = numbers.sorted();
  

  

• limit：限制流中元素的数量。

  Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
  Stream<Integer> limitedNumbers = numbers.limit(3);
  

  

• skip：跳过流中的前几个元素。

  Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
  Stream<Integer> skippedNumbers = numbers.skip(2);
  

• distinct：去除流中重复的元素。

  Stream<Integer> numbers = Stream.of(1, 2, 1, 3, 2, 4);
  Stream<Integer> distinctNumbers = numbers.distinct();
  

这些函数可以组合使用，以实现复杂的数据处理和转换操作。使用流类型函数可以简化代码并提高代码的可读性和可维护性。

四、使用示例

4.1、计算集合中偶数的平方和：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sumOfEvenSquares = numbers.stream()
                               .filter(x -> x % 2 == 0)
                               .mapToInt(x -> x * x)
                               .sum();

4.2、查找集合中最大值：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers.stream()
                                .max(Integer::compareTo);

Stream提供了一种简洁而强大的数据处理方式，可以大大减少代码量并提高代码的可读性和可维护性。