Stream流最佳实战

stream 进行排序、分组、多级分组、交集、并集、差集等

java">package com.al.admin.utils;
 
import cn.hutool.core.util.ObjectUtil;
import lombok.Data;
import org.springframework.util.StringUtils;
 
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
 
/**
 * 测试
 */
public class StreamUtil {
 
    public static void main(String[] args) {
 
        List<Student> students = new ArrayList<>();
        for(int i=0; i<5 ;i++) {
            Student student = new StreamUtil().new Student();
            student.setId(i+"");
            if(i > 2) {
                student.setAge(1);
            } else {
                student.setAge(2);
            }
            if(i > 3) {
                student.setName("zhangsan");
            } else if(i == 0) {
                student.setName(null);
            } else {
                student.setName("lisi");
            }
            student.setMoney(i);
            student.setCreatedDate(null);
            students.add(student);
        }
//多级进行分组 当然也可以进行其他的操作
        Map<String, Map<Integer, List<Student>>> collectq = students.stream()
                .collect(Collectors.groupingBy(x -> StringUtils.isEmpty(x.getName()) ? "" : x.getName(), Collectors.groupingBy(Student::getAge)));
        System.out.println("collectq：" + collectq);
 
        SimpleDateFormat sm = new SimpleDateFormat("yyyy-MM-dd");
        Map<String, List<Student>> groupBy = students.stream().collect(Collectors.groupingBy(a -> sm.format(a.getCreatedDate())));
        System.out.println("==============");
        System.out.println(groupBy);

        /**
         * 条件过滤
         */
        System.out.println("条件过滤==============");
        System.out.println("student.getAge() >1 ==============");
        List<Student> collect = students.stream().filter(student -> student.getAge() > -1).collect(Collectors.toList());
        System.out.println(collect);
 
        /**
         * 正序排列
         */
        System.out.println("正序排列==============");
        collect = collect.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
        System.out.println(collect);
 
        /**
         * 倒序排列
         */
        System.out.println("倒序排列==============");
        collect = collect.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
        System.out.println(collect);
 
        /**
         * string 类型的字段 倒序排列
         */
        System.out.println("string 类型的字段进行倒序排序 ==============");
        collect = collect.stream().sorted(Comparator.comparing(Student::getId).reversed()).collect(Collectors.toList());
        System.out.println(collect);
 
 
        /**
         * string 类型的字段 进行截取 倒序排列
         */
        System.out.println("string 类型的字段进行倒序排序 ==============");
        collect = collect.stream().sorted((o1,o2) -> {
            try {
                return Integer.parseInt(o2.getName().split("-")[1].substring(0,5)) - Integer.parseInt(o1.getName().split("-")[1].substring(0,5));
            } catch (Exception e){
                e.printStackTrace();
            }
            return 0;
        }).collect(Collectors.toList());
        System.out.println(collect);
 
 
        /**
         * 多字段倒序排序
         */
        System.out.println("多字段倒序排序 ==============");
        collect = collect.stream().sorted(Comparator.comparing(Student::getAge).thenComparing(Student::getId).reversed()).collect(Collectors.toList());
        System.out.println(collect);
 
        /**
         * 多字段条件
         */
        System.out.println("age大于20 money大于3000的数据==============");
        Predicate<Student> predicate1 = student -> student.getAge()>20;
        Predicate<Student> predicate2 = student -> student.getMoney()>3000;
        List<Student> collect1 = collect.stream().filter(predicate1.and(predicate2)).collect(Collectors.toList());
        System.out.println(collect1);
 
        /**
         * 两个集合差集 、 并集 、 交集
         * 集合 students 、 collect
         */
        System.out.println("两个集合差集");
        Predicate<Student> predicate =
                user -> collect1.stream()
                        .noneMatch(user1 -> (user.getId()).equalsIgnoreCase(user1.getId()));
        collect = students.stream().filter(predicate).collect(Collectors.toList());
        System.out.println("students - collect1的差集  注意 集合a对集合b之间的差集 和 集合b对集合a之间的差集 不一样");
        System.out.println(collect);
 
        System.out.println("两个集合交集");
        Predicate<Student> predicate3 =
                user -> collect1.stream()
                        .anyMatch(user1 -> (user.getId()).equalsIgnoreCase(user1.getId()));
        collect = students.stream().filter(predicate3).collect(Collectors.toList());
        System.out.println("students - collect1的交集");
        System.out.println(collect);
 
        System.out.println("两个集合并集");
        List<Student> collect2 = students.parallelStream().collect(Collectors.toList());
        List<Student> collect3 = collect1.parallelStream().collect(Collectors.toList());
        collect2.addAll(collect3);
        List<Student> collect4 = collect2.stream().distinct().collect(Collectors.toList());
        System.out.println(collect4);
 
        System.out.println("list 转 map");
        System.out.println("key是list对象中id，value是list对象中的年龄");
        Map<String, Integer> map = students.stream().collect(Collectors.toMap(Student::getId, Student::getAge));
        System.out.println(map);
 
        System.out.println("key是list对象中id，value是list对象");
        Map<String, Student> map1 = students.stream().collect(Collectors.toMap(Student::getId, student -> student));
        System.out.println(map1);
        System.out.println("key是list对象中id，value是list对象 另一种写法");
        Map<String, Student> map2 = students.stream().collect(Collectors.toMap(Student::getId, Function.identity()));
        System.out.println(map2);
 
        System.out.println("key是对象中的某个属性值，value是对象本身，当key冲突时选择第二个key值覆盖第一个key值。");
        Map<String, Student> map3 = students.stream().collect(Collectors.toMap(Student::getId, Function.identity(), (oldValue, newValue) -> newValue));
        System.out.println(map3);
 
        System.out.println("map 转 list");
        List<String> collect5 = map3.keySet().stream().collect(Collectors.toList());
        List<Student> collect6 = map3.values().stream().collect(Collectors.toList());
        System.out.println("map的key转list::"+collect5);
        System.out.println("map的value转list::"+collect6);
 
 
        List<Student> lst = map.entrySet().stream().map(c -> {
            Student student = new StreamUtil().new Student();
            student.setId(c.getKey());
            student.setAge(c.getValue());
            return student;
        }).collect(Collectors.toList());
        System.out.println("通过map的key，value转对象集合");
        System.out.println(lst);
 
    }
 
    @Data
    public class Student {
 
        private String id;
        private int age;
        private double money;
        private String name;
        private Date createdDate;
 
        public Student(){
 
        }
    }
 
}

2、
java中用stream进行去重，排序，分组

java">

3、stream排序

java">    public void test6() {
        List<User> list = new ArrayList<>();
        //定义三个用户对象
        User user1 = new User();
        user1.setUserName("admin");
        user1.setAge(16);
        user1.setSex("男");
        User user2 = new User();
        user2.setUserName("root");
        user2.setAge(20);
        user2.setSex("女");
        User user3 = new User();
        user3.setUserName("admin");
        user3.setAge(18);
        user3.setSex("男");
        User user4 = new User();
        user4.setUserName("admin11");
        user4.setAge(22);
        user4.setSex("女");
        System.out.println(list);
        // 年龄排序(逆序)
        List<User> collect = list.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
        System.out.println(collect);
        // 写法2
        List<User> collect1 = list.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder())).
                collect(Collectors.toList());
        System.out.println(collect1);
        // lambda表达式
        List<User> collect2 = list.stream().sorted((a, b) -> b.getAge() - a.getAge()).collect(Collectors.toList());
        System.out.println(collect2);
        // 并行排序 - 排序数量大时使用并行排序，提高排序速度
        list.parallelStream().sorted().collect(Collectors.toList());
        // 多字段排序1-都进行倒序排序(先根据年龄倒序，再根据用户名倒序)
        List<User> collect3 = list.stream().sorted(Comparator.comparing(User::getAge).
                thenComparing(User::getUserName).reversed()).collect(Collectors.toList());
        System.out.println(collect3);
        // 多字段排序2-先根据年龄逆序，再根据用户名顺序--reversed()是让他前面所有字段进行倒序
        list.stream().sorted(Comparator.comparing(User::getAge).reversed().
                thenComparing(User::getUserName)).collect(Collectors.toList());
        // 多字段排序3
        list.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()).
                thenComparing(User::getUserName, Comparator.reverseOrder())).collect(Collectors.toList());
    }