lambda表达式

源码:

链接：https://pan.baidu.com/s/17G56uQDm6CiogAw0WrYBmA 
提取码：36eb

public class User {

    private int id;

    private String name;

    private String sex;
    
    private int age;

    private int sellNum;

    private BigDecimal salary;
    //................
}

        User u1 = new User(1,"老王","男",25,1,new BigDecimal(12000));
        User u2 = new User(2,"老刘","女",24,3,new BigDecimal(15000));
        User u3 = new User(3,"老李","男",25,1,new BigDecimal(11000));
        User u4 = new User(4,"老魏","女",26,1,new BigDecimal(10000));
        User u5 = new User(5,"老赵","男",25,1,new BigDecimal(12000));
        User u6 = new User(6,"老楚","女",24,2,new BigDecimal(14000));
        User u7 = new User(7,"老朱","男",29,1,new BigDecimal(11000));
        User u8 = new User(8,"老陈","女",26,4,new BigDecimal(14000));
        List<User> list = new ArrayList<User>();
        Collections.addAll(list,u1,u2,u3,u4,u5,u6,u7,u8);

        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"1","2","5","2","3","6","1","2");

        User u9 = new User(9,"老汤","女",26,4,new BigDecimal(14000));
        User u10 = new User(10,"老任","女",25,4,new BigDecimal(14000));
        User u11 = new User(11,"老覃","女",24,4,new BigDecimal(14000));
        List<User> list2 = new ArrayList<User>();
        Collections.addAll(list2,u1,u3,u5,u9,u10,u11);

1. lambda表达式遍历list集合

        /**
         * lambda表达式遍历list集合
         */
        list.forEach(user ->
                System.out.println(user.getName())
        );

2. groupingBy

        /**
         * groupingBy (List<T>转Map<String, List<T>>): 分组指定字段,指定字段为key,符合条件的放到一个一个集合中
         */
        Map<String, List<User>> listMap = list.stream()
                .collect(Collectors.groupingBy(User::getSex));

        listMap.forEach((key,value)->{
            System.out.println(key + "==" + value);
        });

3. filter条件过滤

        /**
         * filter条件过滤
         */
        List<User> filterList = list.stream()
                .filter(user -> !"男".equals(user.getSex()))
                .collect(Collectors.toList());
        for (User user : filterList) {
            System.out.println(user.getName());
        }

4. filter多条件过滤,多个条件中间用&&或者||连接

        /**
         * filter多条件过滤,多个条件中间用&&或者||连接
         */
        List<User> filterList = list.stream()
                .filter(user -> !"男".equals(user.getSex()) && user.getAge() == 24)
                .collect(Collectors.toList());
        for (User user : filterList) {
            System.out.println(user.getName());
        }

5. 求和 基本类型

        /**
         * 求和 基本类型
         * mapToInt
         * mapToDouble
         * mapToLong
         */
        int sum = list.stream()
                .mapToInt(User::getSellNum)
                .sum();
        System.out.println(sum);

6. 求和 大数据类型(例如BigDecimal)

        /**
         * 求和 大数据类型(例如BigDecimal)
         */
        BigDecimal reduce = list.stream()
                .map(User::getSalary)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println(reduce);

7. 最小值

        /**
         * 最小值
         * min(Integer::compareTo) 中Integer是求最小值字段的类型
         */
        Integer min = list.stream()
                .map(User::getAge)
                .min(Integer::compareTo)
                .get();
        System.out.println(min);

8. 最大值

        /**
         * 最大值
         */
        Integer max = list.stream()
                .map(User::getAge)
                .max(Integer::compareTo)
                .get();
        System.out.println(max);

9. 求和,最大值,最小值,平均值

        /**
         * 求和,最大值,最小值,平均值
         */
        LongSummaryStatistics collect = list.stream()
                .collect(Collectors.summarizingLong(User::getAge));
        System.out.println("sum = " + collect.getSum());
        System.out.println("max = " + collect.getMax());
        System.out.println("min = " + collect.getMin());
        System.out.println("avg = " + collect.getAverage());

10. list转map 没有重复键

        /**
         * list转map 没有重复键
         */
        Map<Integer, User> collect = list.stream()
                .collect(Collectors.toMap(User::getId, user -> user));
        for (Map.Entry<Integer, User> entry : collect.entrySet()) {
            System.out.println(entry.toString() + "==" + entry.getValue().toString());
        }

11. list转map 有重复键

        /**
         * list转map 有重复键
         * toMap 如果集合对象有重复的key，会报错 java.lang.IllegalStateException: Duplicate key
         * 可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
         */
        Map<Integer, User> collect = list.stream()
                .collect(Collectors.toMap(User::getAge, user -> user,(k1,k2)->k1));
        for (Map.Entry<Integer, User> entry : collect.entrySet()) {
            System.out.println(entry.toString() + "==" + entry.getValue().toString());
        }

12. 单个字段排序(升序) 1->10

        /**
         * 单个字段排序(升序)  1->10
         */
        list.sort(Comparator.comparing(User::getId));
        list.forEach(user -> System.out.println(user));

13. 单个字段排序(降序) 10->1

        /**
         * 单个字段排序(降序)  10->1
         */
        list.sort(Comparator.comparing(User::getId).reversed());
        list.forEach(user -> System.out.println(user));

14. 多个字段排序

        /**
         * 多个字段排序
         */
        //升序  升序
        list.sort(Comparator.comparing(User::getAge).thenComparing(User::getSellNum));
        //升序  降序
        list.sort(Comparator.comparing(User::getAge).thenComparing(Comparator.comparing(User::getSellNum).reversed()));
        //降序  降序
        list.sort(Comparator.comparing(User::getAge).thenComparing(User::getSellNum).reversed());
        //降序  升序
        list.sort(Comparator.comparing(User::getAge).reversed().thenComparing(User::getSellNum));
        list.forEach(user -> System.out.println(user));

15. distinct() 去重

        /**
         * distinct() 去重
         */
        List<String> collect = list1.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(collect);

16. 获取list某个字段组装成新的list

        /**
         * 获取list某个字段组装成新的list
         */
        List<String> collect = list.stream()
                .map(user -> user.getName())
                .collect(Collectors.toList());
        System.out.println(collect);

17. 交集

        /**
         * 交集
         */
        List<User> collect = list.stream()
                .filter(user -> list2.contains(user))
                .collect(Collectors.toList());
        collect.forEach(user -> System.out.println(user));

18. 差集

        /**
         * 差集
         */
        List<User> collect = list.stream()
                .filter(user -> !list2.contains(user))
                .collect(Collectors.toList());
        collect.forEach(user -> System.out.println(user));