Java8 中根据对象属性去重和集合之间转换

一、List 对象集合根据某个属性去重

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        // 根据 Product 类中的一个属性去重
        List<User> users = list.stream().filter(distinctByKey(User::getName)).collect(Collectors.toList());
        users.forEach(System.out::println);
    }
    /**
     * 根据对象的某个属性去重
     */
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

二、List 对象集合根据多个属性去重

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        // 根据 User 中多个属性去重
        List<User> products = list.stream()
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(
                                () -> new TreeSet<>(Comparator.comparing(
                                        tc -> tc.getName() + ";" + tc.getClass()))), ArrayList::new)); // 需要设置多个去重的字段信息
        products.forEach(System.out::println);
    }

三、List 转换为 Map 集合

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        //1. 根据 User 中的 name 封装 Map 集合 key为 name , value 为 List<User>
        Map<String, List<User>> map1 = list.stream().collect(Collectors.groupingBy(User::getName));
        for (String key : map1.keySet()) {
            System.out.println(key);
            List<User> products1 = map1.get(key);
            products1.forEach(System.out::println);
        }

        //2. 根据 User 中的 id 封装 Map 集合 key为id  value为 User
        Map<Integer, User> map2 = list.stream().collect(Collectors.toMap(User::getId, Function.identity()));
        for (Integer key : map2.keySet()) {
            System.out.println("key = " + key + ", value = " + map2.get(key));
        }
    }

四、List 转换为 Set 集合

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        // 1.根据 User 中名称去重
        Set<String> users = list.stream().map(User::getName).collect(Collectors.toSet());
        for (String name : users) {
            System.out.println(name);
        }

        // List 中对象某个属性去重后，按照字符 - 拼接
        // 2根据 User 中名称，使用 - 连接符连接
        String users2 = list.stream().map(User::getName).distinct().collect(Collectors.joining("-"));
        System.out.println(users2);
    }

五、过滤掉list1中与list2相

public static void main(String[] args) {

        List<Map<String,Object>> list1 = new ArrayList<Map<String,Object>>();
        Map<String,Object> map1 = new HashMap<String,Object>();
        map1.put("name", "111");
        map1.put("age", "21");

        Map<String,Object> map2 = new HashMap<String,Object>();
        map2.put("name", "222");
        map2.put("age", "22");

        Map<String,Object> map3 = new HashMap<String,Object>();
        map3.put("name", "333");
        map3.put("age", "23");


        Map<String,Object> map4 = new HashMap<String,Object>();
        map4.put("name", "444");
        map4.put("age", "24");

        list1.add(map1);
        list1.add(map2);
        list1.add(map3);
        list1.add(map4);
        List<Map<String,Object>> list2 = new ArrayList<Map<String,Object>>();

        Map<String,Object> map11 = new HashMap<String,Object>();
        map11.put("name", "111");
        map11.put("age", "21");

        Map<String,Object> map22 = new HashMap<String,Object>();
        map22.put("name", "222");
        map22.put("age", "22");

        list2.add(map11);
        list2.add(map22);


        //过滤两个list中相同的属性值的数据
        List<Map<String,Object>> list3 = list1.stream().parallel().filter(a -> list2.stream()
                .noneMatch(b-> Objects.equals(a.get("age"), b.get("age")))).collect(Collectors.toList());

        System.out.println(list3);
    }

同的元素，并组成新的集合