在Java 8中，引入了一种新的处理集合数据的方式——Stream。Stream可以让我们更方便地对集合数据进行处理，同时也提供了更好的性能和并行处理能力。在工作中，对集合的处理尤为常见，所以今天来聊一聊Stream
什么是Stream？
Stream是Java 8中引入的一个新的API，它允许我们以声明性的方式对集合数据进行操作。Stream可以处理任何类型的数据，包括基本数据类型、对象和数组等。它提供了一种简单而强大的方式来对数据进行过滤、转换、排序和聚合等操作。
如何创建Stream？
Stream可以从多种数据源创建，包括集合、数组、文件、网络等。以下是一些创建Stream的示例：
// 从集合中创建Stream
List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> stream = list.stream();
// 从数组中创建Stream
int[] array = {1, 2, 3, 4, 5};
IntStream intStream = Arrays.stream(array);
// 从文件中创建Stream
Stream<String> lines = Files.lines(Paths.get("filename.txt"));
// 创建无限Stream
Stream<Integer> stream = Stream.iterate(0, n -> n + 2); // 0, 2, 4, 6, ...
如何操作Stream？
Stream提供了许多操作，可以分为中间操作和终端操作两类。中间操作返回的是一个新的Stream对象，可以进行连续的操作；终端操作会产生一个最终的结果，结束整个操作流程。
以下是一些常用的Stream操作：
中间操作
- filter(Predicate<T> predicate)：根据指定的条件过滤Stream中的元素；
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
.filter(name -> name.length() > 4)
.collect(Collectors.toList());
System.out.println(filteredNames); // Output: [Charlie, David]
- map(Function<T, R> mapper)：将Stream中的元素映射为另一种类型；
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); // Output: [1, 4, 9, 16, 25]
- sorted(Comparator<T> comparator)：根据指定的比较器对Stream中的元素进行排序；
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> sortedNames = names.stream()
.sorted((name1, name2) -> name1.compareTo(name2))
.collect(Collectors.toList());
System.out.println(sortedNames); // Output: [Alice, Bob, Charlie, David]
- distinct()：去除Stream中重复的元素；
List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 1, 4, 5, 4, 3);
List<Integer> distinctNumbers = numbers.stream()
.distinct()
.collect(Collectors.toList());
System.out.println(distinctNumbers); // Output: [1, 2, 3, 4, 5]
- limit(long maxSize)：返回一个不超过指定大小的Stream；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limitedNumbers = numbers.stream()
.limit(3)
.collect(Collectors.toList());
System.out.println(limitedNumbers); // Output: [1, 2, 3]
- skip(long n)：跳过前n个元素，返回剩余的Stream。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skippedNumbers = numbers.stream()
.skip(2)
.collect(Collectors.toList());
System.out.println(skippedNumbers); // Output: [3, 4, 5]
终端操作
- forEach(Consumer<T> action)：对Stream中的每个元素执行指定的操作；
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
names.stream()
.forEach(name -> System.out.println("Hello, " + name + "!"));
// Output: Hello, Alice!
// Hello, Bob!
// Hello, Charlie!
// Hello, David!
- toArray()：将Stream中的元素转换为数组；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer[] numberArray = numbers.stream()
.toArray(Integer[]::new);
System.out.println(Arrays.toString(numberArray)); // Output: [1, 2, 3, 4, 5]
- reduce(T identity, BinaryOperator<T> accumulator)：将Stream中的元素依次归约为一个值；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b);
System.out.println(sum); // Output: 15
- collect(Collector<T, A, R> collector)：将Stream中的元素转换为另一种形式，例如List、Map等；
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Map<String, Integer> nameLengths = names.stream()
.collect(Collectors.toMap(
name -> name,
name -> name.length()));
System.out.println(nameLengths); // Output: {Alice=5, Bob=3, Charlie=7, David=5}
- count()：返回Stream中的元素个数；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream()
.count();
System.out.println(count); // Output: 5
- anyMatch(Predicate<T> predicate)：判断Stream中是否存在满足指定条件的元素；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean hasEvenNumber = numbers.stream()
.anyMatch(n -> n % 2 == 0);
System.out.println(hasEvenNumber); // Output: true
- allMatch(Predicate<T> predicate)：判断Stream中是否所有元素都满足指定条件；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean allNumbersArePositive = numbers.stream()
.allMatch(n -> n > 0);
System.out.println(allNumbersArePositive); // Output: true
- noneMatch(Predicate<T> predicate)：判断Stream中是否不存在满足指定条件的元素；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean noNegativeNumbers = numbers.stream()
.noneMatch(n -> n < 0);
System.out.println(noNegativeNumbers); // Output: true
- findFirst()：返回Stream中的第一个元素；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstNumber = numbers.stream()
.findFirst();
System.out.println(firstNumber); // Output: Optional[1]
- findAny()：返回Stream中的任意一个元素；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> anyNumber = numbers.stream()
.filter(n -> n % 2 == 0)
.findAny();
System.out.println(anyNumber); // Output: Optional[2] (or Optional[4], depending on the stream implementation)
- max(Comparator<T> comparator)：返回Stream中的最大元素；
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> maxNumber = numbers.stream()
.max((n1, n2) -> n1.compareTo(n2));
System.out.println(maxNumber); // Output: Optional[5]
- min(Comparator<T> comparator)：返回Stream中的最小元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> minNumber = numbers.stream()
.min((n1, n2) -> n1.compareTo(n2));
System.out.println(minNumber); // Output: Optional[1]
Stream的并行处理能力
Stream还提供了并行处理能力，可以在多个线程上同时处理数据，提高处理速度。只需要在创建Stream对象时，调用parallel()方法即可启用并行处理。
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.parallelStream().mapToInt(Integer::intValue).sum();
需要注意的是，并不是所有的操作都适合并行处理，例如排序和去重等操作会影响并行处理的效率。
Stream的优点
使用Stream处理数据有以下几个优点：
- 声明性的代码：可以更清晰地表达数据的处理流程，减少冗余代码；
- 更好的性能：Stream可以充分利用多核处理器的性能，提高数据处理效率；
- 与Lambda表达式结合使用：可以更方便地处理数据，减少代码的复杂度和冗余度。
结论
Stream是Java 8中一个强大的API，可以帮助我们更方便地处理集合数据，同时提供了更好的性能和并行处理能力。掌握Stream的相关技术，可以让我们的代码更加简洁、高效、易于维护。
