java1.8之Stream操作

ゞ浴缸里的玫瑰 2024-03-23 11:10 111阅读 0赞

## 1.Stream介绍 ##

*  Stream流是Java 8中引入的一种新型集合处理方式。它可以使开发人员方便地进行集合元素的筛选、过滤、排序等操作，并持有返回结果。Stream流的设计思想是将操作分为中间操作和最终操作两种。
 *  中间操作是指返回Stream类型的方法，可以链式调用，形成一个操作流水线。常用的中间操作包括：filter（过滤）、map（映射）、sort（排序）、distinct（去重）等。
 *  最终操作是指返回非Stream类型的方法，触发流水线执行并得到结果。常用的最终操作包括：forEach（遍历）、toArray（转换为数组）、reduce（聚合计算）、collect（集合转换）、count（计数）等。
 *  Stream流操作具有延迟执行和短路技术的特点。延迟执行指只有在最终操作时才真正处理数据，这样可以避免不必要的计算和占用资源；短路技术指在中间操作中遇到满足条件的元素时就停止计算，提高执行效率。
 *  Stream流操作可以应用于任何类型的集合和数组，包括Java原生的集合类型和第三方库中的数据结构。在使用Stream流时，需要注意空指针异常、并行流导致的线程安全问题等。

## 2.Stream操作 ##

一、创建Stream流

1.  Stream的创建方式

List<String> list = Arrays.asList("apple", "banana", "cherry");
    Stream<String> stream = list.stream();
    stream.forEach(System.out::println);

创建了一个包括“apple”，“banana”和“cherry”的字符串列表，并通过stream()方法将它转换为一个流对象。可以使用forEach()方法将流中的元素逐一打印出来。

1.  通过Stream.of()创建

Stream<String> stream = Stream.of("apple", "banana", "cherry");
    stream.forEach(System.out::println);

使用Stream.of()方法可以轻松创建一个流对象并输出它。

1.  通过Stream.generate()创建

Stream.generate(() -> "fruit").limit(3).forEach(System.out::println);

使用Stream.generate()方法可以创建一个由生成器函数提供的无限流，并通过limit()方法限制生成流的数量，最后使用forEach()方法逐一打印出来。

1.  通过Stream.iterate()创建

Stream.iterate(0, n -> n + 2).limit(5).forEach(System.out::println);

使用Stream.iterate()方法可以创建由迭代函数生成的无限流，并通过limit()方法限制生成流的数量，最后使用forEach()方法逐一打印出来。

二、中间操作

1.  filter()方法：过滤符合条件的元素

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    numbers.stream().filter(n -> n % 2 == 0).forEach(System.out::println);

创建一个包括1至5的整数列表，并筛选出列表中所有偶数并输出。

1.  distinct()方法：去重

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 5);
    numbers.stream().distinct().forEach(System.out::println);

创建一个包括1至5的整数列表，并通过distinct()方法移除重复元素，最后输出不包含重复元素的列表。

1.  map()方法：将元素映射为新的元素

List<String> words = Arrays.asList("apple", "banana", "cherry");
    words.stream().map(String::toUpperCase).forEach(System.out::println);

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并通过map()方法将每个元素都映射为大写字母的形式，最后输出。

1.  flatMap()方法：将多个流组合为一个流

List<String> list1 = Arrays.asList("apple", "banana", "cherry");
    List<String> list2 = Arrays.asList("orange", "pear");
    Stream.of(list1, list2).flatMap(Collection::stream).forEach(System.out::println);

创建两个不同的字符串列表，并将它们组合为一个流。通过flatMap()方法，将每个列表作为一个流，把流中的元素映射并合并到输出中。

1.  limit()方法：用来限制流中元素的数量

Stream.generate(Math::random).limit(3).forEach(System.out::println);

创建一个随机数的流对象，并通过limit()方法限制流中元素的数量为3，最后输出。

1.  sorted()方法：对流中元素进行排序

List<String> list = Arrays.asList("apple", "banana", "cherry");
    list.stream().sorted((s1, s2) -> s1.compareTo(s2)).forEach(System.out::println);

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并对其进行排序输出。

1.  skip()方法：跳过一定数量的元素

List<String> list = Arrays.asList("apple", "banana", "cherry");
    list.stream().skip(2).forEach(System.out::println);

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并通过skip()方法跳过前两个元素，最后输出。

1.  peek()方法：对每个元素进行一些操作，并返回流本身

List<String> list = Arrays.asList("apple", "banana", "cherry");
    list.stream().peek(e -> System.out.println("Processing "+e)).forEach(System.out::println);

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并对每个元素进行一些操作（例如打印），最后输出。

三、终止操作

1.  forEach()方法：将结果逐个迭代输出

List<String> list = Arrays.asList("apple", "banana", "cherry");
    list.stream().forEach(System.out::println);

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并通过forEach()方法逐行输出。

1.  toArray()方法：将流中的元素转化为数组

List<String> list = Arrays.asList("apple", "banana", "cherry");
    String[] arr = list.stream().toArray(String[]::new);
    System.out.println(Arrays.toString(arr));

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并使用toArray()方法将流中元素转化为数组并输出。

1.  reduce()方法：将所有流中的元素累加起来输出结果

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    int sum = list.stream().reduce(0, Integer::sum);
    System.out.println(sum);

创建一个包括1至5的整数列表，并通过reduce()方法将所有元素累加起来并输出结果。

1.  collect()方法：将流中的元素收集到集合中输出

List<String> list = Arrays.asList("apple", "banana", "cherry");
    List<String> newList = list.stream().collect(Collectors.toList());
    System.out.println(newList);

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并使用collect()方法将流中元素添加到集合中，并输出集合对象。

1.  count()方法：对流中的元素数量进行计数

List<String> list = Arrays.asList("apple", "banana", "cherry");
    long count = list.stream().count();
    System.out.println(count);

创建一个包括“apple”，“banana”和“cherry”的字符串列表，并使用count()方法计算其流中元素的数量，最后输出。

四、并行流

并行流可以使处理数据变得更为高效，通过Stream接口中的parallel()方法，可以获得一个顺序流的并行流版本，示例代码如下：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    int sum = list.parallelStream().reduce(0, Integer::sum);
    System.out.println(sum);

创建一个包括1至5的整数列表，并通过parallelStream()方法获得一个并行流对象，然后使用reduce()方法将所有元素累加起来并输出结果。

## 3.总结 ##

1.  Stream是Java 8中新增的API，可以用于处理集合、数组等数据源中的元素。
2.  Stream支持可以被并行化处理的Sequential和Parallel两种模式，可以有效提升数据的处理效率。
3.  Stream提供了很多操作符，例如Filter、Map、Reduce以及FlatMap等，可以方便地操作数据源，达到快速处理数据、筛选数据的目的。
4.  Stream具有延迟计算特性，当执行收集器函数时才会真正开始计算，可以大大减少不必要的计算和消耗。
5.  Stream提供了很多优化方法，例如短路操作和合并操作等，可以大大提升代码的可读性和处理效率。
6.  在使用Stream时，需要注意每个操作符对内存的占用，选择合适的操作符、数据源以及避免过多的中间操作。
7.  Stream可以与Lambda表达式、方法引用等新特性结合使用，编写更简洁、高效的代码。

综上所述，Stream是Java 8中一个非常重要的API，不仅方便了我们处理数据，在某些场景下还能够极大地提升我们程序的性能表现。掌握Stream使用技巧可以让我们编写更为高效、简洁的代码。