集合（五）jdk8新特性之stream流

今天药忘吃喽~ 2023-02-28 11:19 78阅读 0赞

一、集合的基本运算：

import com.alibaba.fastjson.JSON;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
     
    public class StreamDemo {
     
        public static void main(String[] args) {
            List<User> userList = new ArrayList<>();
            User user = new User();
            user.setId("1");
            user.setName("张一");
            userList.add(user);
            user = new User();
            user.setId("4");
            user.setName("张四");
            userList.add(user);
            user = new User();
            user.setId("2");
            user.setName("张二");
            userList.add(user);
            user = new User();
            user.setId("3");
            user.setName("张三");
            userList.add(user);
            user = new User();
            user.setId("5");
            user.setName("张二");
            userList.add(user);
     
            // 获取名称的集合 (stream 串行流)
    //        List<String> collect = userList.stream().map(User::getName).collect(Collectors.toList());
    //        System.out.println("获取名称的集合:" + collect);
    //        //parallelStream() − 为集合创建并行流    并行流是多线程的结果，速度比stream快很多，可能会和stream结果不一致，但是效率很高
    //        collect = userList.parallelStream().map(User::getName).collect(Collectors.toList());
    //        System.out.println("获取名称的集合:" + collect);
     
            // 限制输出
    //        List<String> collect = userList.stream().map(User::getName).limit(3).collect(Collectors.toList());
    //        System.out.println("限制输出三个:" + collect);
     
            // 获取排序的集合
    //        List<String> collect = userList.stream().map(User::getId).sorted().collect(Collectors.toList());
    //        System.out.println("获取排序的集合:"+collect);
     
            // 获取去除重复的集合
    //        List<String> collect = userList.stream().map(User::getName).distinct().collect(Collectors.toList());
    //        System.out.println("获取去除重复的集合:"+collect);
     
            // 过滤
    //        List<String> collect = userList.stream().map(User::getName).filter(str -> !str.isEmpty()).collect(Collectors.toList());
    //        System.out.println("过滤:"+collect);
     
            // 获取集合装字符串
    //        String mergedString = userList.stream().map(User::getName).filter(str -> !str.isEmpty()).collect(Collectors.joining(", "));
    //        System.out.println("直接获取字符串:"+mergedString);
     
            // 获取空字符串的数量
    //        List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    //        long count = strings.stream().filter(string -> string.isEmpty()).count();
    //        System.out.println("获取空字符串的数量:"+count);
     
            // 统计 (总数量，总和，最小值，最大值，平均值)
    //        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
    //        IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
    //        System.out.println("统计:"+stats);
     
            // 获取对应的平方数
    //        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
    //        List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
    //        System.out.println("去重获取平方:"+ JSON.toJSONString(squaresList));
    
    
          //字符串转整形
      //public static Consumer> lambdaConversion() {
         //   return list -> Lists.newArrayList(list.stream()
         //           .mapToInt(Integer::valueOf)
         //           .iterator());
       // }
     
        }
    }

还可以做条件合并查询，如：

List<SchoolProject> schoolTemProjects = temporarySchoolProjects.stream().filter(
                            r -> currSchoolId == r.getSchoolId() &&
                                    currProjectCode() == r.getProjectCode()).collect(Collectors.toList());

二、集成求交集、差集：info  : \['A'  ,'B'  ,'C'  ,'D' , 'E',  'F'\]   ;     list :  \['A'  ,'B'  ,'C'  ,'D' , 'G',  'H'\]

List<TbBaseinfo> differenceSet1 = info.stream().filter(item -> !list.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());//已有数据和提交数据的差集,得到差集\['E',  'F'\]  
List<TbBaseinfo> differenceSet2 = list.stream().filter(item -> !info.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());//提交数据和已有数据的差集，得到差集\['G',  'H'\]  
List<TbBaseinfo> differenceSet = new ArrayList<TbBaseinfo>(differenceSet1);  
differenceSet.addAll(differenceSet2);//两个差集合并在一起  
differenceSet = differenceSet.stream().distinct().collect(Collectors.toList());//合并后的差集去重  \[ 'E',  'F'  ,'G',  'H' \]  
  
//2.已经存在的集合，和本次提交的集合，求交集  
List<TbBaseinfo> intersection = info.stream().filter(item -> list.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList()); //得到交集：\['A'  ,'B'  ,'C'  ,'D'\]  
  
//3.本次保存的集合，和交集，的差集  
List<TbBaseinfo> allDifferenceSet1 = info.stream().filter(item -> !intersection.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//\['A'  ,'B'  ,'C'  ,'D' , 'G',  'H'\]和 \['A'  ,'B'  ,'C'  ,'D'\]的差集,得到差集：\['G',  'H'\]  
List<TbBaseinfo> allDifferenceSet2 = intersection.stream().filter(item -> !info.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//\['A'  ,'B'  ,'C'  ,'D'\]和 \['A'  ,'B'  ,'C'  ,'D' , 'G',  'H'\]的差集,得到差集：\[\]  
List<TbBaseinfo> allDifferenceSet = new ArrayList<EcBaseinfo>(allDifferenceSet1);  
allDifferenceSet.addAll(allDifferenceSet2);   //合并差集为：\['G',  'H'\]  
allDifferenceSet = allDifferenceSet.stream().distinct().collect(Collectors.toList());   //去重还是\['G',  'H'\]  
  
List<TbBaseinfo> allDifference = allDifferenceSet;  
  
//4.最终的差集，和第一次的差集,的交集，即是要添加的，差集即是要删除的  
List<TbBaseinfo> addList = differenceSet.stream().filter(item -> !allDifference.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//\['G',  'H'\]和\[ 'E',  'F'  ,'G',  'H' \]的交集：\['G',  'H'\]，即是要添加的，插入  
List<TbBaseinfo> delList = differenceSet.stream().filter(item -> allDifference.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())).collect(Collectors.toList());

//\['G',  'H'\]和\[ 'E',  'F'  ,'G',  'H' \]的差集：\['E',  'F'\]，即是要删除的

三、集合转化为Map：

List转换为Map，使用Collectors.toMap方法进行转换：User类，分别有id，name,age三个属性。List集合,userList，存储User对象

1、指定key-value，value是**对象中的某个属性值**。

Map<Integer,String> userMap1 = userList.stream().collect(Collectors.toMap(User::getId,User::getName));

2、指定key-value，value是**对象本身**，User->User 是一个返回本身的lambda表达式

Map<Integer,User> userMap2 = userList.stream().collect(Collectors.toMap(User::getId,User->User));

3、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身

Map<Integer,User> userMap3 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

4、指定key-value，value是对象本身，**Function.identity()是简洁写法，也是返回对象本身，key 冲突的解决办法，这里选择第二个key覆盖第一个key**。

Map<Integer,User> userMap4 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(),(key1,key2)->key2));

5、Map<String, List<User>> userMap = sList.stream().collect(Collectors.groupingBy(User::getSchoolId));  
User::getSchoolId可以用user->user.getSchoolId()来代替