探索Java 8 Stream API：现代数据处理的新纪元

Stream流

Stream初探：何方神圣？

Stream流是一种处理集合数据的高效工具，它可以让你以声明性的方式处理数据集合。Stream不是存储数据的数据结构，而是对数据源（如集合、数组）的运算操作概念，支持函数式编程风格

特性

• 可以配合lambda写出简洁代码。
• 链式操作：支持一系列中间操作（如filter, map）和最终操作（如forEach, collect），这些操作可以链接起来，形成一个管道来处理数据。
• 延迟执行：中间操作不会立即执行，而是构建一个执行计划，直到遇到最终操作时才一次性完成所有操作，这种方式可以提高效率。
• 并行处理：支持并行处理，通过调用parallelStream()方法，可以轻松地利用多核处理器的优势，无需手动编写多线程代码。
• 类型安全：利用泛型，Stream操作可以在编译期检查类型错误，提高代码的安全性和可读性。

如何获得Stream流

Java提供了几种方式,可以让我们获得Stream流

1. [集合创建流]Collection 接口的 stream()或 parallelStream()方法
2. [自由值创建]静态的 Stream.of(…)、Stream.empty()方法
3. [数组创建流]Arrays.stream(array)
4. 静态的 Stream.generate()方法生成无限流，接受一个不包含引元的函数
5. 静态的 Stream.iterate()方法生成无限流，接受一个种子值以及一个迭代函数
6. Pattern 接口的 splitAsStream(input)方法
7. 静态的 Files.lines(path)、Files.lines(path, charSet)方法
8. 静态的 Stream.concat()方法将两个流连接起来

代码演示

          /*
         * 三种常用获得流的方法
         * 1.Collection接口中的stream()方法
         * 2.Stream类的静态方法 of()
         * 3.Arrays工具类的stream(T[] array)方法
         *
         */
        // 用Collection接口中的stream()方法，获得流
        ArrayList<Integer> list = new ArrayList<>();// 创建集合
        list.add(1);
        list.add(2);
        list.add(3);
        Stream<Integer> stream1 = list.stream();// 获得流

        // 2.Stream类的静态方法 of()
        Stream<Integer> stream2 = Stream.of(1, 2, 3, 4);// 获得流

        //3.Arrays工具类的stream(T[] array)方法
        int[] arr = {1,2,3,4};
        IntStream stream3 = Arrays.stream(arr);// 获得流

Stream方法操作

Stream流就是流式处理数据,流的操作有很多种

• 中间操作(真正处理数据的操作)
  • 中间操作就是执行完返回的是一个流,即可以**继续执行**流操作
  • 敲代码来说,就是使用中间操作的方法,写完继续再.调用其他方法
• 终止操作(将操作完的结果返回)
  • 敲代码来说,调用终止方法,代码就结束;

操作	函数	说明
中间操作	filter(Predicate)	将结果为false的元素过滤掉
中间操作	map(Function)	转换元素的值，可以用方法引元或者lambda表达式
中间操作	flatMap(Function)	若元素是流，将流摊平为正常元素，再进行元素转换(合并两个流为一个流)
中间操作	limit(long n)	保留前n个元素
中间操作	skip(long n)	跳过前n个元素
中间操作	concat(Stream s1, Stream s2)	将两个流拼接起来
中间操作	distinct()	剔除重复元素
中间操作	sorted()	将Comparable元素的流排序
中间操作	sorted(Comparator)	将流元素按Comparator排序
中间操作	peek(Consumer)	流不变，但会把每个元素传入fun执行，可以用作调试
终结操作	max(Comparator)	取最大值
终结操作	min(Comparator)	取最小值
终结操作	count()	统计元素数量
终结操作	findFirst()	获得流的第一个元素
终结操作	findAny()	返回任意元素
终结操作	anyMatch(Predicate)	任意元素匹配时返回true
终结操作	allMatch(Predicate)	所有元素匹配时返回true
终结操作	noneMatch(Predicate)	没有元素匹配时返回true
终结操作	reduce(Function)	从流中计算某个值，接受一个二元函数作为累积器，从前两个元素开始持续应用它，累积器的中间结果作为第一个参数，流元素作为第二个参数
终结操作	iterator()	迭代器迭代元素
终结操作	forEach(Consumer)	lambda的方式迭代
终结操作	forEachOrdered(Consumer)	可以应用在并行流上以保持元素顺序

5.2.1 中间操作

下面演示流的操作使用 - 中间操作

package day613.jdk8New.stream;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.stream.Stream;

public class StreamAPITest {
    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();// 创建集合
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Stream<Integer> stream1 = list.stream();// 获得流
        /*
         * void forEach(Consumer<? super T> action);
         * ---遍历流
         * ---参数类型：Consunmer
         * -----使用lambda重写Consumer接口的 void accept(T t)
         */
        //遍历流
        //stream1.forEach(t -> System.out.print(t + " "));// 1 2 3 4 5 6
        
        /*
         * Stream<T> filter(Predicate<? super T> predicate);
         * ---过滤，即过滤掉不想要的数据，留下想要的
         * ---参数类型 Predicate
         * -----使用lambda重写Predicate接口的 boolean test(T t)
         */

        //过滤奇数，留下偶数
        //stream1.filter(t->t % 2 == 0).forEach(t-> System.out.print(t + " "));// 2 4 6
        
        /*
         * <R> Stream<R> map(Function<? super T, ? extends R> mapper);
         * ---转换元素的值
         * ---参数类型 Function
         * -----使用lambda重写Function接口的 R apply(T t)
         */
        //将流中的整型转换成字符串类型，并遍历
        //stream1.map(t->String.valueOf(t)).forEach(t-> System.out.print(t + " "));//1 2 3 4 5 6

        /*
         *  Stream<T> limit(long maxSize);
         * ---保留前maxSize个元素
         * ---参数类型 long
         */
        //保留前四个
        //stream1.limit(4).forEach(t-> System.out.print(t + " "));// 1 2 3 4

        /*
         *   Stream<T> skip(long n);
         * ---跳过前n个元素
         * ---参数类型 long
         */
        
        //跳过前四个
        //stream1.skip(4).forEach(t-> System.out.print(t + " "));// 5 6

        /*
         * Stream<T> sorted(Comparator<? super T> comparator);
         * ---排序
         * ---参数类型 Comparator
         * -----使用lambda重写Comparator接口的 int compare(T o1, T o2);
         */
        //降序排序
        stream1.sorted((o1,o2) -> o2 - o1 ).forEach(t-> System.out.print(t + " "));

       
    }

}

练习:

给定ArrayList<Integer>集合,
先过滤数据只保留偶数,
后对数据进行降序排序,
去除重复元素,
将元素转成String类型
后将每个元素拼接上《》后输出 

  public static void test() {
        ArrayList<Integer> list = new ArrayList<>( );
        list.add(3);
        list.add(1);
        list.add(3);
        list.add(2);
        list.add(4);
        list.add(6);
        list.add(5);
        list.add(7);
        list.add(5);
        list.add(6);
        list.add(9);
        list.add(8);
        list.add(10);
        list.add(7);

        // 获得流
        Stream<Integer> stream = list.stream( );
        // 先过滤数据只保留偶数
        // 后对数据进行降序排序,
        // 去除重复元素,
        // 将元素转成String类型
        // 后将每个元素拼接上《》后输出
        stream.filter(e -> e % 2 == 0)
                .sorted((o1,o2) -> o2 - o1)
                .distinct()
                .map(e -> String.valueOf(e))
                .forEach(e -> System.out.println("《"+e+"》" ));
    }

5.2.3 注意事项

Stream流的操作注意事项

1. 流的操作只能使用一次,也就是说执行过终结操作后不能再继续使用

   否则报错报错IllegalStateException stream has already been closed

2. 使用中间操作,返回新的流

3. 没有终止操作,就不会有结果,换句话说,没有终结操作,中间操作是 不会执行的

	public static void test2() {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.filter((e) -> {
            System.out.println("正在过滤元素:"+e );
            return e % 2 == 0;
        });
        // 没有终结操作,中间的filter不会执行,输出语句不会执行
    }

5.3 流的收集

流操作完,将数据流中的数据再返回成数组和集合 --> 这就是收集流

将流收集到集合或数组中

• collect() 收集到集合
  • collect(Collectors.toList( )) 将stream流中的数据,收集到List集合
  • collect(Collectors.toSet( )) 将stream流中的数据,收集到set集合
• toArray 收集到数组

		ArrayList<Integer> list = new ArrayList<>( );
        list.add(3);
		// 获得流
        Stream<Integer> stream = list.stream( );
        // 先过滤数据只保留偶数
        // 后对数据进行降序排序,
        // 去除重复元素,
        // 将元素转成String类型
        // 变成ArrayList<String>返回
        List<String> list2 = stream.filter(e -> e % 2 == 0)
                .sorted((o1, o2) -> o2 - o1)
                .distinct( )
                .map(e -> String.valueOf(e))
                .collect(Collectors.toList( ));// 收集为List集合

---

最后

如果感觉有收获的话，点个赞 👍🏻 吧。
❤️❤️❤️本人菜鸟修行期，如有错误，欢迎各位大佬评论批评指正！😄😄😄

💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍