JDK8的lambda中steam对集合的操作

古城微笑少年丶 2022-02-12 15:17 640阅读 0赞

本文是转载  
收集 高手的优秀代码 学习  
[原文链接][Link 1]

自定义排序以及过滤所需数据

List<String> list = new ArrayList<>();
            list.add("two2");
            list.add("one");
            list.add("three");
            //默认
            System.out.println(list);
            System.out.println("----------------------------------");
            /**
             * 基本使用stream以及lambda
             */
            //留下长度小于3的值
            list.stream().filter(s -> s.length() <= 3).forEach(s -> System.out.println(s));
            System.out.println("----------------------------------");
            //默认排序
            list.stream().sorted().forEach(s -> System.out.println(s));
            System.out.println("----------------------------------");
            //自定义排序
            list.stream().sorted((s1,s2) -> s1.length() - s2.length()).forEach(s -> System.out.println(s));
            System.out.println("----------------------------------");
            //将所有英文字母大写
            list.stream().map(s -> s.toUpperCase()).forEach(s -> System.out.println(s));
            System.out.println("----------------------------------");

将一个集合中存放的多个集合内容进行平铺

//将一个集合中存放的多个集合内容进行平铺
            List<List> allList = new ArrayList<>();
            List<String> oneList = new ArrayList<>();
            oneList.add("one");
            oneList.add("two");
            List<String> twoList = new ArrayList<>();
            twoList.add("three");
            twoList.add("four");
            allList.add(oneList);
            allList.add(twoList);
            allList.stream().flatMap(s ->s.stream()).forEach(s -> System.out.println(s));
            System.out.println("----------------------------------");

取出一组集合中长度最长的字符串

/**
             * 使用reduce
             */
            //取出一组集合中长度最长的字符串
            List<String> reduceList = new ArrayList<>();
            reduceList.add("one");
            reduceList.add("two");
            reduceList.add("three");
            reduceList.add("four");
            //方法一
            Optional<String> wayOne = reduceList.stream().max((s1, s2) -> s1.length() - s2.length());
            System.out.println(wayOne.get());
            //方法二
            Optional<String> wayTwo = reduceList.stream().reduce((s1, s2) -> s1.length() >= s2.length() ? s1 : s2);
            System.out.println(wayTwo.get());
            System.out.println("----------------------------------");

取出一组集合中所有字符串长度的总和

//取出一组集合中所有字符串长度的总和
            List<String> lengthCountList = new ArrayList<>();
            lengthCountList.add("one");
            lengthCountList.add("two");
            lengthCountList.add("three");
            Integer size = lengthCountList.stream().reduce(0, (max, str) -> max + str.length(), (a, b) -> a + b);
            System.out.println(size);
            System.out.println("----------------------------------");

将list转换成map key为字符串 value为字符串长度

/**
             * 使用collect
             */
            //将list转换成map key为字符串 value为字符串长度
            List<String> collectList = new ArrayList<>();
            collectList.add("a");
            collectList.add("ab");
            collectList.add("abc");
            //  Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t -> t形式的Lambda表达式。
            Map<String, Integer> collectMap = collectList.stream().collect(Collectors.toMap(Function.identity(), str -> str.length()));
            System.out.println(collectMap);
            System.out.println("----------------------------------");

以60为界限将集合进行划分

//以60为接线将集合进行划分
            List<Integer> partitionList = new ArrayList<>();
            partitionList.add(58);
            partitionList.add(59);
            partitionList.add(62);
            Map<Boolean, List<Integer>> partitionMap = partitionList.stream().collect(Collectors.partitioningBy(s -> s >= 60));
            System.out.println(partitionMap);
            System.out.println("----------------------------------");

根据年龄进行划分

//根据年龄进行划分
            //准备数据
            List<User> userList = new ArrayList<>();
            User user1 = new User();
            user1.setName("beyondLi1");
            user1.setAge(18);
            User user2 = new User();
            user2.setName("beyondLi2");
            user2.setAge(18);
            User user3 = new User();
            user3.setName("beyondLi3");
            user3.setAge(20);
            User user4 = new User();
            user4.setName("beyondLi4");
            user4.setAge(22);
            userList.add(user1);
            userList.add(user2);
            userList.add(user3);
            userList.add(user4);
            //分类
            Map<Integer, List<User>> groupUser1 = userList.stream().collect(Collectors.groupingBy(User::getAge));
            //或
            Map<Integer, List<User>> groupUser2 = userList.stream().collect(Collectors.groupingBy(s -> s.getAge()));
            System.out.println(groupUser1);
            System.out.println(groupUser2);
            System.out.println("----------------------------------");

根据年龄进行划分，求出各年龄的人数

//根据年龄进行划分，求出各年龄的人数
            //数据使用上面的user集合
            Map<Integer, Long> groupMap = userList.stream().collect(Collectors.groupingBy((User::getAge), Collectors.counting()));
            System.out.println(groupMap);
            System.out.println("----------------------------------");

根据年龄进行划分,查看个分组的人名

//根据年龄进行划分,查看个分组的人名
            Map<Integer, List<String>> groupList = userList.stream().collect(Collectors.groupingBy(User::getAge, Collectors.mapping(User::getName, Collectors.toList())));
            System.out.println(groupList);
            System.out.println("----------------------------------");

对字符串集合进行拼接

List<String> joiningList = new ArrayList<>();
            joiningList.add("My");
            joiningList.add("name");
            joiningList.add("is");
            joiningList.add("beyondLi");
            //以逗号分割
            String joiningStringOne = joiningList.stream().collect(Collectors.joining(","));
            System.out.println(joiningStringOne);
            //以逗号分割使用花括号扩起
            String joiningStringTwo = joiningList.stream().collect(Collectors.joining(",", "{", "}"));
            System.out.println(joiningStringTwo);
    
    
    
    
    顺带 stream 流的函数式用法
            List<Person> javaList=new ArrayList<Person>(){
            {
                add(new Person("depp","male",10));
                add(new Person("tom","male",30));
                add(new Person("suci","female",20));
                add(new Person("jack","male",23));
            }
             
            };
             
            String phs = javaList  
                      .stream()  
                      .map(Person::getName)  
                      .collect(joining(" ; "));
                 }
    			
    		System.out.println(phs); 
    		// 输出 depp ; tom ; suci ; jack
    		// 对象成员变量  Person(name, string ,number)

String字符串转成List数据格式  
String str = “1,2,3,4,5,6” -> List listLong \[1,2,3,4,5,6\];

private List<Long> stringToLongList(String strArr) {
            return Arrays.stream(strArr.split(","))
                    .map(s -> Long.parseLong(s.trim()))
                    .collect(Collectors.toList());
        }

String字符串转成List数据格式  
String str = “q,w” -> List listLong \[‘q’,‘w’\];

private List<String> stringToList(String strArr) {
            return Arrays.stream(strArr.split(","))
                    .map(s -> s.trim())
                    .collect(Collectors.toList());
        }

[Link 1]: https://blog.csdn.net/liboyang71/article/details/76221870