Stream流的使用

最新推荐文章于 2024-06-24 15:15:46 发布

Aska小强

最新推荐文章于 2024-06-24 15:15:46 发布

阅读量1k

点赞数

文章标签： java spring springboot

本文链接：https://blog.csdn.net/qq_34285557/article/details/104498032

版权

Stream流的使用

本篇主要讲解JDK8中 Stream流的使用，包括如何筛选、切片、映射、查找、匹配、归约等等每个类型都会有对应的案例简单易懂

1.Stream的概念

Stream API是JDK8新添加的处理集合的关键组件，这里的Stream流和I/O流不同，Stream是对集合对象功能的增强，它专注对集合对象提供各种便利的操作，只要给出需要对其包含的元素执行什么操作，比如“过滤掉长度大于10的字符串”、“获取每个字符串的首字母”等，Stream会隐式地在内部进行遍历，做出相应的数据转换。

2.Stream流的创建

2.1 从集合创建

     List<Integer> list = new ArrayList<>();

    //1.从集合创建流
    list.stream();
    list.parallelStream();

2.2 从数组创建

    //Arrays的静态方法 stream 
     Arrays.stream(new int[] {1, 2, 3,});

2.3 创建数字流

    //IntStream流 
       int intarr[] = {1,2,3};
       IntStream.of(1,2,3);
    IntStream.of(intarr);

    //LongStream流
    long longarr[] = {1L , 2L , 3L};
    LongStream.of(longarr);

2.4 创建无限流

     //通过Random的 ints longs doubles 创建一个无限流  一般要限制个数 通过 limit是限制个数

    new Random().ints().limit(10).forEach((i) -> System.out.println(i));
    new Random().longs();
    new Random().doubles();

2.5 自己创建Stream

    通过 Stream.generate(Supplier<T> s) 自己去实现Supplier 函数式接口，去提供数据

    //如下 通过Random去提供
    Random random = new Random();
    Stream.generate(() -> random.nextInt()).limit(20).forEach((i) -> System.out.println(i));

    //通过 Stream的 of        
    Stream.of("Hello" , "Stream")

3.Stream提供的常用的方法

Stream提供了一些便利的方法

    map()  映射
    filter() 过滤/筛选
    limit() 限制数量
    skip()  跳过数量
    reduce() 归约
    distinct() 去重
    sorted()  排序
    collect() 收集 结合Collectors.toList()使用
    forEach() 遍历
    ...

4.Stream流的中间操作

Stream流的中间操作，就是这个操作返回还是一个Stream流，不是一个最终结果，中间操作比如要有一个终止操作的方法调用才会执行

Stream流的中间操作分为2类 无状态操作：当前的操作和其元素的前后没有依赖关系
有状态操作：当前的操作的结果需要依赖其他的元素

5.Stream流的终止操作

Stream流的终止操作，会返回一个最终的结果，只有有终止操作中间操作才会执行

Stream流的终止操作分为2类非短路操作：当前操作中间是不会断的，也就是需要流中的数据全部执行完毕短路操作：当前操作不需要等待全部数据执行完毕，可能到某个数据执行完毕后就结束流

6.筛选和切片

filter
distinct
limit
skip

准备数据

        //id name age 对应属性
        Student student = new Student(1, "johnny", 23);
        Student student1 = new Student(2, "candy", 25);
        Student student2 = new Student(2, "ruby", 25);
        Student student3 = new Student(3, "lucy", 33);
        Student student4 = new Student(4, "jack", 53);

        List<Student> studentList = new ArrayList<>();
        studentList.add(student);
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);

6.1 谓词筛选 filter

Stream 接口支持 filter 方法，该操作会接受一个谓词（一个返回 boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。

如下：这个谓语就是 age>25

      List<Student> filterStudent = studentList.stream().filter(s -> s.getAge() > 25)
                .collect(Collectors.toList());

6.2 筛选重复 distinct

Stream 接口支持 distinct 的方法，它会返回一个元素各异（根据流所生成元素的 hashCode和equals方法实现）的流

       //得到Student所有的年纪并且去重
       List<Integer> ageList  = studentList.stream().map(s -> s.getAge())
                .distinct()
                .collect(Collectors.toList());

6.3 限制元素 limit

Stream 支持limit(n)方法，该方法会返回一个不超过给定长度的流。所需的长度作为参数传递给limit。如果流是有序的，则最多会返回前n个元素

        List<Integer> limitAgeList = studentList.stream().map(s -> s.getAge())
                .limit(2)
                .collect(Collectors.toList());
        System.out.println(limitAgeList);

6.4 跳过指定数量元素

Stream 支持 skip(n) 方法，返回一个扔掉了前n个元素的流。如果流中元素不足n个，则返回一个空流。

        List<Integer> skipAgeList = studentList.stream().map(s -> s.getAge())
                .skip(2)
                .collect(Collectors.toList());

7.映射

map
flatMap

7.1 map

Stream 支持 map 方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素

        List<Integer> mapAageList = studentList.stream().map(s -> s.getAge())
                .collect(Collectors.toList());

7.2 flatMap

Stream 流支持 flatmap 方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流

注意 chars()方法返回的是IntStream ，需要装箱 boxed，转换为Stream，因为IntStream并不是Stream的子类

下面的例子flatMap就是分别把前2个 student的name属性转换为一个流，并且将其合为一个流

        List<Integer> flatMapList = studentList.stream()
                .limit(2)
                .flatMap(s -> s.getName().chars().boxed())
                .collect(Collectors.toList());

        flatMapList.stream().forEach(i -> System.out.println((char)i.intValue()));

打印

8.查找和匹配

anyMatch
allMatch
nonMatch
findAny
findFirst

8.1 anyMatch

流中是否有一个元素能匹配给定的谓词，有则返回true 否则返回false。

        //anyMatch 查找流中是否有满足谓语的，存在就返回true 否则就返回false
        boolean isExistAgeUp50 = studentList.stream()
                .anyMatch(s -> s.getAge() > 50);

8.2 allMatch

流中是否有所有元素能匹配给定的谓词。

        boolean allMatchFlag = studentList.stream()
                .allMatch(s -> s.getAge() > 10);

8.3 nonMatch

流中是否有没有任何元素能匹配给定的谓词。

        boolean noneMatchFlag =  studentList.stream()
                .noneMatch(s -> s.getAge() > 100);

8.4 findAny

findAny 方法将返回当前流中的任意一个元素。注意在非并行流下大多情况返回第一个元素，但是不保证

           Optional<Student> studentOptional =  studentList.parallelStream()
                .findAny();

8.5 findFirst

findFirst 方法将返回当前流中的第一个元素。

         studentList.stream()
                .map(s->s.getAge() * 2)
                .filter(i -> i % 2==0)
                .findFirst().ifPresent(i -> System.out.println(i));

9.归约

reduce

就是把一个流中的元素经过lambda反复进行操作，指到流被归约成一个值

reduce方法有3种形式：

把一个流中的元素组合起来，使用 reduce 操作来表达更复杂的查询，比如“计算菜单中的总卡路里”或“菜单中卡路里最高的菜是哪一个”。此类查询需要将流中所有元素反复结合起来，得到一个值，比如一个Integer。这样的查询可以被归类为归约操作（将流归约成一个值）。

reduce方法接受两个参数：一个初始值，这里是0；一个 BinaryOperator 来将两个元素结合起来产生一个新值，这里我们用的是 lambda (a, b) -> a + b。

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

10.排序

sorted

下面代码以自然序排序一个list

    list.stream().sorted()

自然序逆序元素，使用Comparator 提供的reverseOrder() 方法,前提是流中的元素要实现了Comparator接口，比如Integer 这种

    list.stream().sorted(Comparator.reverseOrder())

使用Comparator 来排序一个list

    list.stream().sorted(Comparator.comparing(Student::getAge))

把上面的元素逆序

    list.stream().sorted(Comparator.comparing(Student::getAge).reversed())

案例：将按照学生的Age属性排序和倒序

           studentList.stream()
                .sorted(Comparator.comparing(Student::getAge))
                .forEach(System.out::println);

        studentList.stream()
                .sorted(Comparator.comparing(Student::getAge).reversed())
                .forEach(System.out::println);

11.收集

collect

将流元素进行中间操作后进行收集到一个List 或者Set 中去,结合Collectors的方法

        studentList.stream()
                .map(Student::getAge)
                .collect(Collectors.toList());

        studentList.stream()
                .map(Student::getAge)
                .collect(Collectors.toSet());

12.总结

本篇主要讲解JDK8中 Stream流的使用，流是什么如何创建以及常用方法包括如何筛选、切片、映射、查找、匹配、归约等等每个类型都会有对应的案例简单易懂。

个人博客网站 https://www.askajohnny.com 欢迎来访问！

本文由博客一文多发平台 OpenWrite 发布！

Aska小强

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫