java8之lambda表达式的23种使用总结

本是古典何须时尚 2022-09-04 09:55 13阅读 0赞

package com.lyc.collections;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.io.Serializable;
    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Date;
    import java.util.List;
    import java.util.LongSummaryStatistics;
    import java.util.Map;
    import java.util.function.BinaryOperator;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    /** * lambda表达式测试 * * @author lyc * @date 2021/8/5 */
    public class LycLambdaCollections { 
    
        /** * 1、遍历list集合 * * @param list */
        public static void foreachColl(List<Employee> list) { 
            System.out.println("--------------------------------------------------------------");
            list.forEach(employee -> { 
                System.out.println(employee.toString());
            });
        }
    
        /** * 2、获取集合中对象的某一个属性的集合 */
        public static void getOnlyIdList(List<Employee> list) { 
            System.out.println("getOnlyIdList result===========================");
            List<Long> idList = list.stream().map(employee -> employee.getId()).collect(Collectors.toList());
            System.out.println("firstMethod employee -> employee.getId():");
            System.out.println(idList.toString());
            System.out.println("");
            System.out.println("secondMethod Employee::getId:");
            List<Long> idListTwo = list.stream().map(Employee::getId).collect(Collectors.toList());
            System.out.println(idListTwo);
        }
    
        /** * 3、获取集合中对象的某一个属性的集合并对属性做类型转换 * * @param list */
        public static void getOneFiledWithDeal(List<Employee> list) { 
            List<Long> deptNoList = list.stream().map(employee -> employee.getDeptNo()).map(Long::valueOf).collect(Collectors.toList());
            System.out.println(deptNoList.toString());
        }
    
        /** * 4、将数组元素做其他处理后转成list集合 * * @param list */
        public static void getOneFiledFromArray(List<Employee> list) { 
            List<String> nameList = list.stream().map(employee -> employee.getName()).collect(Collectors.toList());
            String str = String.join(",", nameList);
            List<String> upperNameList = Arrays.stream(str.split(",")).map(String::toUpperCase).collect(Collectors.toList());
            System.out.println(upperNameList.toString());
        }
    
        /** * 5、将集合对象按<集合中对象的某个属性、对象本身>转成map----->简单分组,key为对象一个属性值，值为对象本身 * * @param list */
        public static void groupByIdForObjectMap(List<Employee> list) { 
            Map<Long, Employee> map = list.stream().collect(Collectors.toMap(Employee::getId, employee -> employee));
            System.out.println(map);
        }
    
        /** * 6、将集合对象按<集合中对象的某个属性、集合中对象的另一个个属性>转map----->简单分组2，key为对象一个属性值，值为对象的某一个属性值 * * @param list */
        public static void groupByIdForOneFiledMap(List<Employee> list) { 
            Map<Long, String> map = list.stream().collect(Collectors.toMap(Employee::getId, Employee::getName));
            System.out.println(map);
        }
    
        /** * 7、将集合对象按<集合中对象的某个属性、集合中对象的另一个个属性>转map----->简单分组3，key为对象一个属性值，值为对象的某一个属性值 * （这种场景存在key重复的需要指定用哪个覆盖哪个） * * @param list */
        public static void groupByRepeatNameForOneFiledMap(List<Employee> list) { 
            // 保留前面的元素
            Map<String, Long> map1 = list.stream().collect(Collectors.toMap(Employee::getName, Employee::getId, (k1, k2) -> k1));
            System.out.println(map1);
    
            // 用后面的元素覆盖
            Map<String, Long> map2 = list.stream().collect(Collectors.toMap(Employee::getName, Employee::getId, (k1, k2) -> k2));
            System.out.println(map2);
        }
    
        /** * 8、将集合对象按<对象的某个属性、List<对象本身>>转map------>复杂分组,key为对象一个属性值，值为对象集合 * * @param list */
        public static void groupByIdForListObjectMap(List<Employee> list) { 
            Map<String, List<Employee>> map = list.stream().collect(Collectors.groupingBy(Employee::getDeptNo));
            System.out.println(map);
        }
    
        /** * 9、将集合对象按<对象的某个属性、List<对象的某个属性>>转map------>复杂分组2,key为对象一个属性值，值为对象的一个属性值集合 * * @param list */
        public static void groupByIdForOneFiledListMap(List<Employee> list) { 
            Map<String, List<Long>> map = list.stream().collect(Collectors.groupingBy(Employee::getDeptNo, Collectors.mapping(Employee::getId, Collectors.toList())));
            System.out.println(map);
        }
    
        /** * 10、将集合对象按<对象的某个属性、List<对象的某个属性>>转map------>复杂分组3,key为对象一个属性值，值为对象的一个属性值集合 * (这个写法需要保证key唯一，使用场景是将唯一key的对象其他多个属性合并为集合) * * @param list */
        public static void groupByIdForManyFiledListMap(List<Employee> list) { 
            Map<Long, List<Long>> map = list.stream().collect(Collectors.toMap(Employee::getId, employee -> Arrays.asList(employee.getId(), 2L)));
            System.out.println(map);
        }
    
        /** * 11、求所有的薪资总和，返回一个值------>求和 * * @param list */
        public static void sumAll(List<Employee> list) { 
            // 先将list转成stream流
            // 获取salary
            // 自定义计算salary总和
            // 第一个参数表示求和的初始值、第二个参数表示上一步求和的中间值以及本次要计算的值(subNum,salary) 实现就是将求和的中间值与本次的值相加
            Long totalSum = list.stream().map(Employee::getSalary).reduce(0L, (subNum, salary) -> (subNum + salary));
            System.out.println(totalSum);
    
            Long totalSum2 = list.stream().map(Employee::getSalary).reduce(0L, Long::sum);
            System.out.println(totalSum2);
    
            Long totalSum3 = list.stream().mapToLong(Employee::getSalary).sum();
            System.out.println(totalSum3);
    
            // 测试备份下BigDecimal类型的求和
            BigDecimal totalQty = list.stream().map(p -> p.getTestQty().multiply(p.getTestQty())).reduce(BigDecimal.ZERO, BigDecimal::add);
            System.out.println(totalSum3);
        }
    
        /** * 12、将集合中的对象按某个属性分组，并对每个分组中对象的另一个属性求和------>分组并求和 * * @param list */
        public static void sumGroupById(List<Employee> list) { 
            Map<String, LongSummaryStatistics> map = list.stream().collect(Collectors.groupingBy(Employee::getDeptNo, Collectors.summarizingLong(Employee::getSalary)));
            System.out.println(map);
    
            Map<String, Long> map2 = list.stream().collect(Collectors.groupingBy(Employee::getDeptNo, Collectors.summingLong(Employee::getSalary)));
            System.out.println(map2);
    
            Map<String, Long> map3 = list.stream().collect(Collectors.groupingBy(Employee::getDeptNo, Collectors.reducing(0L, Employee::getSalary, Long::sum)));
            System.out.println(map3);
        }
    
        /** * 13、求集合中的对象按某个属性最小值------>求最小值 * * @param list */
        public static void minAll(List<Employee> list) { 
            Long min = list.stream().mapToLong(Employee::getSalary).min().getAsLong();
            System.out.println(min);
    
            Long min2 = list.stream().min(Comparator.comparing(Employee::getSalary)).get().getSalary();
            System.out.println(min2);
    
            Long min3 = list.stream().collect(Collectors.minBy(Comparator.comparing(Employee::getSalary))).get().getSalary();
            System.out.println(min3);
        }
    
        /** * 14、将集合中的对象按某个属性分组，并对每个分组中对象的另一个属性求最小值------>分组并求最小值 * * @param list */
        public static void minGroupBy(List<Employee> list) { 
            Map<String, Employee> map = list.stream()
                    .collect(Collectors.toMap(Employee::getDeptNo, Function.identity(), BinaryOperator.minBy(Comparator.comparing(Employee::getSalary))));
            System.out.println(map);
        }
    
        /** * 15、将集合中的对象按多个条件过滤，返回过滤后的对象集合------>多条件过滤 * 年龄小于30且薪资大于6000的 * * @param list */
        public static void filterByCondition(List<Employee> list) { 
            list = list.stream().filter(employee -> employee.getAge() < 30 && employee.getSalary() > 6000).collect(Collectors.toList());
            foreachColl(list);
        }
    
        /** * 16、按一个条件正序排列------>正序排 * 按年龄从小到达排序 * * @param list */
        public static void sortOneConditionNature(List<Employee> list) { 
            List<Employee> list1 = list.stream().sorted((o1, o2) -> o1.getAge() - o2.getAge()).collect(Collectors.toList());
            foreachColl(list1);
    
            List<Employee> list2 = list.stream().sorted(Comparator.comparing(Employee::getAge)).collect(Collectors.toList());
            foreachColl(list2);
        }
    
        /** * 17、按多个条件都正序排列------>正序正序排 【两个都正不加reversed()】 * 按年龄从小到达排序，再按薪水从小到大排序 * * @param list */
        public static void sortTwoConditionAllNature(List<Employee> list) { 
            List<Employee> list1 = list.stream().sorted((o1, o2) -> { 
                int flag = o1.getAge() - o2.getAge();
                if (flag == 0) { 
                    flag = (int) (o1.getSalary() - o2.getSalary());
                }
                return flag;
            }).collect(Collectors.toList());
            foreachColl(list1);
    
            List<Employee> list2 = list.stream().sorted(Comparator.comparing(Employee::getAge).thenComparing(Employee::getSalary)).collect(Collectors.toList());
            foreachColl(list2);
        }
    
        /** * 18、按一个条件倒序排列----->倒序排 * 按年龄从大到小排序 * * @param list */
        public static void sortOneConditionReverse(List<Employee> list) { 
            List<Employee> list1 = list.stream().sorted((o1, o2) -> o2.getAge() - o1.getAge()).collect(Collectors.toList());
            foreachColl(list1);
    
            List<Employee> list2 = list.stream().sorted(Comparator.comparing(Employee::getAge,Comparator.reverseOrder())).collect(Collectors.toList());
            foreachColl(list2);
    
            List<Employee> list3 = list.stream().sorted(Comparator.comparing(Employee::getAge).reversed()).collect(Collectors.toList());
            foreachColl(list3);
        }
    
        /** * 19、按多个条件都倒序排列---->倒序倒序排 【两个都倒序在最后面加一个reversed()即可】 * 按年龄从大到小排序，再按薪水从大到小排 * * @param list */
        public static void sortTwoConditionAllReverse(List<Employee> list) { 
            List<Employee> list1 = list.stream().sorted((o1, o2) -> { 
                int flag = o2.getAge() - o1.getAge();
                if (flag == 0) { 
                    flag = (int) (o2.getSalary() - o1.getSalary());
                }
                return flag;
            }).collect(Collectors.toList());
            foreachColl(list1);
    
    
            List<Employee> list2 = list.stream().sorted(Comparator.comparing(Employee::getAge, Comparator.reverseOrder()).thenComparing(Employee::getSalary, Comparator.reverseOrder()))
                    .collect(Collectors.toList());
            foreachColl(list2);
    
            List<Employee> list3 = list.stream().sorted(Comparator.comparing(Employee::getAge).thenComparing(Employee::getSalary).reversed()).collect(Collectors.toList());
            foreachColl(list3);
    
    
        }
    
        /** * 20、按多个条件先正序排再倒序排---->先正序后倒序【先正加reversed()，后倒加reversed()】 * 按年龄从小到大，再按薪水从大到小排序 * * @param list */
        public static void sortTwoConditionOneNatureOneReverse(List<Employee> list) { 
            List<Employee> list1 = list.stream().sorted(Comparator.comparing(Employee::getAge).thenComparing(Employee::getSalary,Comparator.reverseOrder())).collect(Collectors.toList());
            foreachColl(list1);
    
            List<Employee> list2 = list.stream().sorted(Comparator.comparing(Employee::getAge).reversed().thenComparing(Employee::getSalary).reversed()).collect(Collectors.toList());
            foreachColl(list2);
        }
    
        /** * 21、按多个条件先倒序排再正序排---->先倒序后正序【先倒序的加reserved()，后正序的不加】 * 按年龄从大到小，再按薪水从小到大排序 * * @param list */
        public static void sortTwoConditionOneReverseOneNature(List<Employee> list) { 
            List<Employee> list1 = list.stream().sorted(Comparator.comparing(Employee::getAge,Comparator.reverseOrder()).thenComparing(Employee::getSalary)).collect(Collectors.toList());
            foreachColl(list1);
    
            List<Employee> list2 = list.stream().sorted(Comparator.comparing(Employee::getAge).reversed().thenComparing(Employee::getSalary)).collect(Collectors.toList());
            foreachColl(list2);
        }
    
        /** * 22、取集合元素的某几个值去重后转集合----->抽取对象多个值转集合去重 * 求所有人的地址集合，去重 * * @param list */
        public static void getMultiToSet(List<Employee> list) { 
            List<String> list1 = list.stream().flatMap(e -> Stream.of(e.getFmAddress(), e.getToAddress())).distinct().collect(Collectors.toList());
            System.out.println(list1);
        }
    
        /** * 23、根据集合元素的某些信息组装新对象---->对象A组装对象B返回 * 抽取用户ID、姓名、部门信息返回简单对象DTO * * @param list */
        public static void getNewList(List<Employee> list) { 
            List<SimpleEmpDto> list1 = list.stream().map(e -> { 
                SimpleEmpDto dto = new SimpleEmpDto();
                dto.setId(e.getId());
                dto.setName(e.getName());
                dto.setDeptNo(e.getDeptNo());
                return dto;
            }).collect(Collectors.toList());
            list1.forEach(dto -> System.out.println(dto));
        }
    
    	public static void main(String[] args) { 
            List<Employee> list = EmployeeFactory.buildEmployByChain();
            foreachColl(list);
            //getOnlyIdList(list);
            //getOneFiledWithDeal(list);
            //getOneFiledFromArray(list);
            //groupByIdForObjectMap(list);
            //groupByIdForOneFiledMap(list);
            //groupByRepeatNameForOneFiledMap(list);
            //groupByIdForListObjectMap(list);
            //groupByIdForOneFiledListMap(list);
            //groupByIdForManyFiledListMap(list);
            //sumAll(list);
            //sumGroupById(list);
            //minAll(list);
            //minGroupBy(list);
            //filterByCondition(list);
            //sortOneConditionNature(list);
            //sortTwoConditionAllNature(list);
            //sortOneConditionReverse(list);
            //sortTwoConditionAllReverse(list);
            //sortTwoConditionOneNatureOneReverse(list);
            //sortTwoConditionOneReverseOneNature(list);
            //getMultiToSet(list);
            //getNewList(list);
        }
    
    }
    
    
    
    /** * 雇员Bean */
    @Data
    @Builder
    @AllArgsConstructor
    @NoArgsConstructor
    class Employee implements Serializable { 
        private static final long serialVersionUID = -3966543324371928911L;
    
        /** * 编号 */
        private Long id;
    
        /** * 姓名 */
        private String name;
    
        /** * 年龄 */
        private Integer age;
    
        /** * 薪水 */
        private Long salary;
    
        /** * 生日 */
        private Date birthday;
    
        /** * 爱好 */
        private List<String> favorites;
    
        /** * 所属部门编号（数字类型的） */
        private String deptNo;
    
        /** * 从哪来 */
        private String fmAddress;
    
        /** * 到哪去 */
        private String toAddress;
    
        /** * 测试BigDecimal类型的属性计算 */
        private BigDecimal testQty;
    
        @Override
        public String toString() { 
            return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + ", birthday="
                    + (null == birthday ? "" : DateUtils.formatToStringDefault(birthday)) + ", favorites=" + favorites + ", deptNo='" + deptNo + '\'' + '}';
        }
    }
    
    
    /** * 简单雇员Bean */
    @Data
    @Builder
    @AllArgsConstructor
    @NoArgsConstructor
    class SimpleEmpDto implements Serializable { 
        private static final long serialVersionUID = 8479182105142615840L;
    
        /** * 编号 */
        private Long id;
    
        /** * 姓名 */
        private String name;
    
        /** * 所属部门编号（数字类型的） */
        private String deptNo;
    
        @Override
        public String toString() { 
            return "SimpleEmpDto{" + "id=" + id + ", name='" + name + '\'' + ", deptNo='" + deptNo + '\'' + '}';
        }
    }
    
    
    /** * 构建测试数据 */
    class EmployeeFactory { 
        public static List<Employee> buildEmployByChain(){ 
            List<Employee> list = new ArrayList<Employee>();
            list.add(Employee.builder().id(1L).name("yangsan").age(20).salary(3000L)
                    .birthday(DateUtils.parseToDate("2001-01-01",DateUtils.single_format))
                    .deptNo("1").favorites(Arrays.asList("film","music")).fmAddress("中国").toAddress("中国").build());
    
            list.add(Employee.builder().id(2L).name("lisi").age(18).salary(3000L)
                    .birthday(DateUtils.parseToDate("2003-01-01",DateUtils.single_format))
                    .deptNo("3").favorites(Arrays.asList("play","music")).fmAddress("中国").toAddress("美国").build());
    
            list.add(Employee.builder().id(3L).name("wangwu").age(45).salary(7000L)
                    .birthday(DateUtils.parseToDate("1976-01-01",DateUtils.single_format))
                    .deptNo("2").favorites(Arrays.asList("swim","sing")).fmAddress("法国").toAddress("意大利").build());
    
            list.add(Employee.builder().id(4L).name("huangbo").age(30).salary(5000L)
                    .birthday(DateUtils.parseToDate("1991-01-01",DateUtils.single_format))
                    .deptNo("3").favorites(Arrays.asList("running","read")).fmAddress("日本").toAddress("韩国").build());
    
            list.add(Employee.builder().id(5L).name("yilong").age(25).salary(4000L)
                    .birthday(DateUtils.parseToDate("1996-01-01",DateUtils.single_format))
                    .deptNo("1").favorites(Arrays.asList("bike","code")).fmAddress("朝鲜").toAddress("中国").build());
    
            list.add(Employee.builder().id(6L).name("xiayu").age(34).salary(5500L)
                    .birthday(DateUtils.parseToDate("1987-01-01",DateUtils.single_format))
                    .deptNo("3").favorites(Arrays.asList("game","music")).fmAddress("巴基斯坦").toAddress("中国").build());
    
            list.add(Employee.builder().id(7L).name("yangsanqi").age(29).salary(8000L)
                    .birthday(DateUtils.parseToDate("1992-01-01",DateUtils.single_format))
                    .deptNo("1").favorites(Arrays.asList("shopping","music")).fmAddress("中国").toAddress("英国").build());
    
            list.add(Employee.builder().id(8L).name("yangsanba").age(18).salary(2000L)
                    .birthday(DateUtils.parseToDate("2003-01-01",DateUtils.single_format))
                    .deptNo("1").favorites(Arrays.asList("eating","music")).fmAddress("俄罗斯").toAddress("法国").build());
            return list;
        }
    }