java 8 Lambda表达式List<Map>转实体，及一些常用方法

java8 lambda表达式 进行对list<Map>的分组求和

public static void main(String[] args) {
        List<Map<String,Object>> list = new ArrayList<>();
        Map map = new HashMap();
        map.put("projId","12121");
        map.put("count","5");
        map.put("projectCode","wwww");
        Map map1 = new HashMap();
        map1.put("projId","11111");
        map1.put("count","3");
        map1.put("projectCode","SDJISJD");
        Map map2 = new HashMap();
        map2.put("projId","11111");
        map2.put("count","4");
        map2.put("projectCode","SDJISJD");
        list.add(map);
        list.add(map1);
        list.add(map2);
        List<Map<String,Object>> result =new ArrayList<>();
        //下面的forEach只是处理一些值  可以不加
        list.stream().forEach(k->{
            k.put("company","公司");
            k.put("projectName","哈哈哈");
        });
        //这个是对你list里面map的某个key进行分组 (会把key的对应的value相同的map放到同一个list里面)
        Map<String, List<Map<String, Object>>> glist = list.stream().collect(Collectors.groupingBy(e -> e.get("projectCode").toString()));
        glist.forEach((k,slist)->{
            Map<String,Object> nmap=new HashMap<>();
            //这块是对某个key进行计算  可以求和 求平均值  求各种值
            IntSummaryStatistics sumcc = slist.stream().collect(Collectors.summarizingInt(e->Integer.valueOf(e.get("count").toString())));
            nmap.put("company", slist.get(0).get("company"));
            nmap.put("projectName", slist.get(0).get("projectName"));
            nmap.put("projectCode", slist.get(0).get("projectCode"));
            nmap.put("count", sumcc.getSum());//求和
            result.add(nmap);
        });
        //这块是把处理好的list<map>转换传list<实体类>
        List<SendDailyResponseDO>  ss = result.stream().map(m -> new SendDailyResponseDO(m.getOrDefault("company", "").toString(), m.getOrDefault("projectName", "").toString(), m.getOrDefault("projectCode", "").toString(), m.getOrDefault("projId", "").toString(),((Number)m.getOrDefault("count", "")).intValue()))
                .collect(Collectors.toList());
        System.out.println(ss.toString());
    }

java8 lambda表达式 进行对JSON的转换，转实体类  Map

JSONObject json = JSON.parseObject(channelages);
Map<String, List<ClientUpdateByChannelageId>> result = json.entrySet()
      .stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> JSON.parseArray(String.valueOf(entry.getValue()), ClientUpdateByChannelageId.class)));

List<ClientUpdateByChannelageId> channelages1 = result.get("channelages");

 

java8 一个List按照另一个List的数据顺序来排序

 

public static void main(String[] args) {
 

        //排序的条件
        List<String> orderRegulation = Arrays.asList("G102", "G103", "G108", "29", "28", "25", "24", "G109", "G105", "26", "21");
        //targetList进行排序
        List<Posts> targetList = new ArrayList<Posts>();
 
        Posts post3 = new Posts();
        post3.setId("G102");
        post3.setName("xiaoli3");
        post3.setAge("23");
 
        Posts post2 = new Posts();
        post2.setId("G103");
        post2.setName("xiaoli2");
        post2.setAge("22");
 
        Posts post4 = new Posts();
        post4.setId("G109");
        post4.setName("xiaoli4");
        post4.setAge("25");
 
        Posts post7 = new Posts();
        post7.setId("G107");
        post7.setName("xiaoli7");
        post7.setAge("21");
 
        Posts post8 = new Posts();
        post8.setId("G101");
        post8.setName("xiaoli8");
        post8.setAge("26");
 
        Posts post5 = new Posts();
        post5.setId("G105");
        post5.setName("xiaoli5");
        post5.setAge("27");
 
        Posts post1 = new Posts();
        post1.setId("G104");
        post1.setName("xiaoli1");
        post1.setAge("29");
 
        Posts post6 = new Posts();
        post6.setId("G106");
        post6.setName("xiaoli6");
        post6.setAge("23");
 
        Posts post9 = new Posts();
        post9.setId("G106");
        post9.setName("xiaoli9");
        post9.setAge("25");
 
        Posts post10 = new Posts();
        post10.setId("G104");
        post10.setName("xiaoli10");
        post10.setAge("28");
 
        targetList.add(post1);
        targetList.add(post2);
        targetList.add(post3);
        targetList.add(post4);
        targetList.add(post5);
        targetList.add(post6);
        targetList.add(post7);
        targetList.add(post8);
        targetList.add(post9);
        targetList.add(post10);
        System.out.println("排列前的数据：");
        targetList.forEach(t -> System.out.print(t.getId() + t.getName() + "~" + t.getAge() + "  "));
        System.out.println();
 
        setListOrder(orderRegulation, targetList);
 
        System.out.println("排序的规则：");
        orderRegulation.forEach(t -> System.out.print(t + " "));
        System.out.println();
        System.out.println("排列后的数据：");
        targetList.forEach(t -> System.out.print(t.getId() + t.getName() + "~" + t.getAge() + " "));
 
    }
 
    //平时排序可使用其中一种，下面是综合两个条件排序
    public static void setListOrder(List<String> orderRegulation, List<Posts> targetList) {
        //按照Posts的Id来排序
        Collections.sort(targetList, ((o1, o2) -> {
            int io1 = orderRegulation.indexOf(o1.getId());
            int io2 = orderRegulation.indexOf(o2.getId());
            //如果排序的值多余排序条件里面的值，把多余的值放到排序值的后面
            if (io1 == -1) {
                io1 = targetList.size() - io1;
            }
            if (io2 == -1) {
                io2 = targetList.size() - io2;
            }
 
            return io2 - io1;
        }));
 
        //按照Posts的age来排序
        Collections.sort(targetList, ((o1, o2) -> {
            int io1 = orderRegulation.indexOf(o1.getAge());
            int io2 = orderRegulation.indexOf(o2.getAge());
 
            if (io1 == -1) {
                io1 = targetList.size() - io1;
            }
            if (io2 == -1) {
                io2 = targetList.size() - io2;
            }
 
            return io2 - io1;
        }));
    }

 

Stream多字段Comparator.comparing().thenComparing()排序

1. 两字段都升序

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(i);
            user.setAge(50-i);
            list.add(user);
        }
        for (int j = 0; j < 5; j++) {
            User user = new User();
            user.setId(j);
            user.setAge(j);
            list.add(user);
        }
        list.forEach(l->{
            System.out.println(l.toString());
        });
        System.out.println("===============================");
        List<User> list1 = list.stream().sorted(Comparator.comparing(User::getId).thenComparing(User::getAge)).collect(Collectors.toList());
        list1.forEach(l->{
            System.out.println(l.toString());
        });
    }

2. 两字段降序

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(i);
            user.setAge(50-i);
            list.add(user);
        }
        for (int j = 0; j < 5; j++) {
            User user = new User();
            user.setId(j);
            user.setAge(j);
            list.add(user);
        }
        list.forEach(l->{
            System.out.println(l.toString());
        });
        System.out.println("===============================");
        List<User> list1 = list.stream().sorted(Comparator.comparing(User::getId).thenComparing(User::getAge).reversed()).collect(Collectors.toList());
        list1.forEach(l->{
            System.out.println(l.toString());
        });
    }

3. 第一字段升序，第二字段降序

 

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(i);
            user.setAge(50-i);
            list.add(user);
        }
        for (int j = 0; j < 5; j++) {
            User user = new User();
            user.setId(j);
            user.setAge(j);
            list.add(user);
        }
        list.forEach(l->{
            System.out.println(l.toString());
        });
        System.out.println("===============================");
        List<User> list1 = list.stream().sorted(Comparator.comparing(User::getId).reversed().thenComparing(User::getAge).reversed()).collect(Collectors.toList());
        list1.forEach(l->{
            System.out.println(l.toString());
        });
    }

4. 第一字段降序，第二字段升序

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(i);
            user.setAge(50-i);
            list.add(user);
        }
        for (int j = 0; j < 5; j++) {
            User user = new User();
            user.setId(j);
            user.setAge(j);
            list.add(user);
        }
        list.forEach(l->{
            System.out.println(l.toString());
        });
        System.out.println("===============================");
        List<User> list1 = list.stream().sorted(Comparator.comparing(User::getId).reversed().thenComparing(User::getAge)).collect(Collectors.toList());
        list1.forEach(l->{
            System.out.println(l.toString());
        });
    }

个人理解，从右往左看，第二字段取决于它后面是否降序，决定其是否降序，而第一字段取决于两字段是否降序，类似于双重否定等于肯定，决定其是否降序。

最后记录一下Comparator.nullsFirst()的用法

list.stream().sorted(Comparator.comparing(User::getId, Comparator.nullsFirst(Integer::compareTo))
                .thenComparing(User::getAge, Comparator.nullsFirst(Integer::compareTo))).collect(Collectors.toList());