lambda表达式对集合的常见操作

1，先创建对象并赋值

public class Cat {
    // 颜色
    private String colour;
    // 价格
    private Integer price;
    // 名字
    private String name;
}

public class Student {

    private String Name;

    private String Age;
}

    private  ArrayList<Student> students = new ArrayList<>();

    private ArrayList<Student> stus = new ArrayList<>();

    private ArrayList<Cat> cats = new ArrayList<>();

    {
        students.add(new Student("aaa","111"));
        students.add(new Student("bbb","222"));
        students.add(new Student("ccc","333"));
        students.add(new Student("ddd","444"));

        stus.add(new Student("aaa","111"));
        stus.add(new Student("eee","555"));
        stus.add(new Student("fff","666"));
        stus.add(new Student("ccc","333"));

        cats.add(new Cat("黑色",12000,"熊熊是崽崽"));
        cats.add(new Cat("银渐层",3000,"晚晚"));
        cats.add(new Cat("银渐层",5000,"大圆子"));
        cats.add(new Cat("海双色",30000,"王鱼鱼"));
        cats.add(new Cat("乳白色",7000,"一个鸡腿子"));
    }

2，lambda对两个集合对{交集，差集，合集,数量统计}

 

        // 交集
        List<Student> collect = students.stream().filter(
                item -> stus.stream().map(p -> p.getName()).collect(Collectors.toList()).contains(item.getName())
        ).collect(Collectors.toList());
        System.out.println(String.format("lambda: %s","取两个集合的交集"));
        System.out.println(collect.toString());

        // 差集
        // a集合除交集外的值
        List<Student> collect1 = students.stream().filter(
                item -> !stus.stream().map(p -> p.getName()).collect(Collectors.toList()).contains(item.getName())
        ).collect(Collectors.toList());
        // b集合除交集外的值
        List<Student> collect2 = stus.stream().filter(
                item -> !students.stream().map(p -> p.getName()).collect(Collectors.toList()).contains(item.getName())
        ).collect(Collectors.toList());
        collect1.addAll(collect2);
        System.out.println(String.format("lambda: %s","取两个集合的差集"));
        System.out.println(collect1.toString());
        
        // 根据name获取两个结合的合集，去掉重复的值
        students.addAll(
                stus.stream().filter(
                        p -> students.stream().map(s -> s.getName()).collect(Collectors.toList()).contains(p.getName())
                ).collect(Collectors.toList())
        );
        // 求同时出现在students和stus中的对象数量(name相同即视为同一对象)
                int size1 = students.stream().filter(
                p -> stus.stream().map(s -> s.getName()).collect(Collectors.toList()).contains(p.getName())
        ).collect(Collectors.toList()).size();
        System.out.println(String.format("lambda: 名称相同的对象数量为%d(优化后)",size1));

3，数值求和，平均值等

        // 获取价格最高的小猫咪
        Optional<Cat> max = cats.stream().max((p1, p2) -> Integer.compare(p1.getPrice(), p2.getPrice()));
        Cat cat = max.get();
        System.out.println(String.format("价格最高的小猫咪：%s",cat.toString()));
        // 获取价格最低的小猫咪
        Optional<Cat> min = cats.stream().min((p1, p2) -> Integer.compare(p1.getPrice(), p2.getPrice()));
        Cat cat1 = min.get();
        System.out.println(String.format("价格最低的小猫咪：%s",cat1.toString()));
        // 获取价格大于1万的小猫咪数量
        long count = cats.stream().filter(p -> p.getPrice() > 10000).count();
        System.out.println(String.format("价格大于1万的小猫咪数量：%s",count));
        // List转map
        Map<String, Cat> collect = cats.stream().collect(Collectors.toMap(key -> key.getName(), value -> value));
        System.out.println(collect);
        // List转set
        Set<Cat> collecta = cats.stream().collect(Collectors.toSet());
        System.out.println(String.format("List转set：%s",collecta));
        // 按照小猫咪的价格从低到高排序
        List<Cat> collect1 = cats.stream().sorted((p1, p2) -> Integer.compare(p1.getPrice(), p2.getPrice())).collect(Collectors.toList());
        System.out.println(String.format("按照小猫咪的价格从低到高排：%s",collect1));
        // 按照小猫咪低价格从高到低排
        List<Cat> collect2 = cats.stream().sorted((p1, p2) -> Integer.compare(p2.getPrice(), p1.getPrice())).collect(Collectors.toList());
        System.out.println(String.format("按照小猫咪的价格从高到底排：%s",collect2));
        // 获取小猫咪的平均价格
        OptionalDouble average = cats.stream().mapToInt(p -> p.getPrice()).average();
        System.out.println(average);
        // 把价格大于1万与小于1万的小猫咪分成两个集合并放到一个map中
        Map<Boolean, List<Cat>> collect3 = cats.stream().collect(Collectors.groupingBy(p -> p.getPrice() > 10000, Collectors.toList()));
        collect3.forEach((p1,p2)-> System.out.println(p1+":"+p2));
        // 求所有小猫咪的总价
        Integer integer = cats.stream().map(p -> p.getPrice()).reduce((p1, p2) -> p1 + p2).get();
        // 求所有小猫咪的总价，也可这种实现，更简洁
        int sum = cats.stream().mapToInt(p -> p.getPrice()).sum();
        System.out.println(String.format("小猫咪的总价：%s",sum));