Java8新特性-Stream对集合进行操作的常用API

拼搏现实的明天。 2023-09-30 14:39 12阅读 0赞

## 场景 ##

Java 8扩展了集合类，可以通过 Collection.stream()或者 Collection.parallelStream()来创建一个Stream。

利用Stream，在对集合比如list进行处理时就不用再进行繁琐的循环遍历操作了。

比如：

遍历一个对象list并输出每个的年龄属性

userList.stream().filter(user -> user.getAge() > 40).forEach(item -> System.out.println(item.getAge()));

注：

博客：  
[霸道流氓气质的博客\_CSDN博客-C\#,架构之路,SpringBoot领域博主][CSDN_-C_SpringBoot]  
关注公众号  
霸道的程序猿  
获取编程相关电子书、教程推送与免费下载。

## 实现 ##

一、Stream的创建

有3种方法，示例代码如下

//1、通过java.util.Collection.stream()方法用集合创建流
            List<String> list = Arrays.asList("zhansan","lisi","wangwu");
            Stream<String> stream = list.stream();
            stream.forEach(System.out::println);
            //2、通过java.util.Arrays.stream(T[]array)方法用数组创建流
            String[] array = {"zhansan","lisi","wangwu"};
            Stream<String> stream2 = Arrays.stream(array);
            stream2.forEach(System.out::println);
            //3、使用Stream的静态方法:of() iterate() generate()
            Stream<Integer> stream3 = Stream.of(1,2,3);
            stream3.forEach(System.out::println);
            Stream<Integer> stream4 = Stream.iterate(0,(x->x+3)).limit(4);
            stream4.forEach(System.out::println);
            //双冒号运算操作符是类方法的句柄，lambda表达式的一种简写。双冒号（::）运算符在Java 8中被用作方法引用（method reference）
            //这种[方法引用]或者说[双冒号运算]对应的参数类型是Function<T,R>T表示传入类型，R表示返回类型。比如表达式person->person.getAge();
            // 传入参数是person，返回值是person.getAge() 可替换成Person::getAge
            Stream<Double> stream5 = Stream.generate(Math::random).limit(3);
            stream5.forEach(System.out::println);

二、常用API

1、首先创建并构造对象list

新建User对象

package com.ruoyi.demo.domain;
    
    public class User {
        private  String name;
        private  int age;
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

然后构造userlist

private static List<User> userList = new ArrayList<User>();
    
            //创建User集合
            userList.add(new User("霸道",30));
            userList.add(new User("的",40));
            userList.add(new User("程序猿",50));
            userList.add(new User("张三",60));
            userList.add(new User("李四",70));

2、过滤filter和遍历forEach

//api的使用-过滤filter和遍历forEach
            //userList.stream().filter(user -> user.getAge() > 40).forEach(item -> System.out.println(item.getAge()));

如果筛选条件是多个，比如筛选年龄介于40到70之间

//多个筛选，少选年龄介于40到70之间
            //userList.stream().filter(user -> user.getAge() > 40 && user.getAge() < 70).forEach(item -> System.out.println(item.getAge()));

3、匹配第一个findFirst

//匹配第一个findFirst
            //System.out.println("匹配第一个findFirst:"+userList.stream().filter(user ->user.getAge()<60).findFirst().get().getName());

4、是否包含符合特定条件的元素anyMatch

//是否包含符合特定条件的元素anyMatch
            //System.out.println("是否包含年龄大于80的元素:"+userList.stream().anyMatch(user -> user.getAge()>80));

5、按条件筛选特定条件的元素

//按条件筛选并形成新的集合collect(Collectors.toList())
            //userList.stream().filter(user -> user.getAge() > 40).collect(Collectors.toList()).forEach(item->System.out.println(item.getAge()));

6、聚合max、min、count

//聚合max min count
            //获取User中年龄最大的，最小的同理
            //Comparator<User> comparator = Comparator.comparing(User::getAge);
            //System.out.println("聚合max,年龄最大的是："+userList.stream().max(comparator).get().getAge());
            //获取年龄大于40的个数
            //System.out.println("年龄大于40的个数是："+userList.stream().filter(x ->x.getAge()>40).count());

7、map与flatmap

//map 与 flatmap
            //map:接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
            //给每个User的年龄加10 注意此时后面再次forEach的时候，每个item代表的是age,则不再是user了
            //userList.stream().map(user -> user.getAge() + 10).collect(Collectors.toList()).forEach(item -> System.out.println(item));
            //另外除了map之外还有一个flatmap:接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

8、reduce缩减，求和、求积、求最值

//规约reduce 把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
            List<Integer> list = Arrays.asList(1, 2, 3, 4);
            //求和
            //Optional<Integer> reduceAdd = list.stream().reduce((x, y)->x+y);
            //求乘积
            //Optional<Integer> reduceMul = list.stream().reduce((x, y)->x*y);
            //求最大值
            Optional<Integer> reduceMax = list.stream().reduce((x, y)->x>y?x:y);
            //System.out.println(reduceMax.get());

9、收集toList、toSet、toMap

//收集 toList toSet toMap
            //年龄大于50的User转换成map
            Map<String,User> map = userList.stream().filter(user -> user.getAge()>50).collect(Collectors.toMap(User::getName,y->y));
            //System.out.println(map);

10、Collectors提供了一系列的用于数据统计的静态方法

//Collectors提供了一系列用于数据统计的静态方法
            //计数
            //System.out.println(userList.stream().collect(Collectors.counting()));
            //求平均值
            //System.out.println(userList.stream().collect(Collectors.averagingInt(User::getAge)));
            //求和
            //System.out.println(userList.stream().collect(Collectors.summingInt(User::getAge)));
            //一次性统计所有(计数、求和、求平均、最大值、最小值)
            //System.out.println(userList.stream().collect(Collectors.summarizingInt(User::getAge)));

11、分组

//分组
            //按照年龄是否大于50进行分组
            Map<Boolean,List<User>> userPart = userList.stream().collect(Collectors.partitioningBy(user -> user.getAge()>50));
            //System.out.println(userPart);
            //按照年龄进行分组
            Map<Integer,List<User>> userGroup = userList.stream().collect(Collectors.groupingBy(User::getAge));
            //System.out.println(userGroup);

12、连接

//连接joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
            String nameString = userList.stream().map(user -> user.getName()).collect(Collectors.joining("和"));
            //System.out.println(nameString);

13、排序

//排序sorted
            //按照年龄升序排序
            //System.out.println(userList.stream().sorted(Comparator.comparing(User::getAge)).map(User::getAge).collect(Collectors.toList()));
            //按照年龄降序排序
            //System.out.println(userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).map(User::getAge).collect(Collectors.toList()));

14、提取、组合

//提取、组合
            String[] arr = {"1","2","3","4"};
            String[] arr1 = {"3","4","5","6"};
            Stream<String> stream = Stream.of(arr);
            Stream<String> stream1 = Stream.of(arr1);
            //concat合并两个流
            //List<String> collect = Stream.concat(stream, stream1).collect(Collectors.toList());
            //System.out.println(collect);
            //distinct去重
            //List<String> collect1 = Stream.concat(stream, stream1).distinct().collect(Collectors.toList());
            //System.out.println(collect1);

15、限制

//限制从流中获取前n个数据
            //System.out.println(Stream.iterate(1,x -> x+2).limit(5).collect(Collectors.toList()));
            //skip 跳过前n个数据
            System.out.println(Stream.iterate(1,x -> x+2).skip(5).limit(5).collect(Collectors.toList()));

[CSDN_-C_SpringBoot]: https://blog.csdn.net/badao_liumang_qizhi