lambda表达式对list集合转map操作

//对list转换成Map，重复的car_id取id最大的一条记录；直接上代码：

---

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 测试lambda表达式
 * 根据car_id分组，取id最大的记录；
 * @author 有点皮
 * @date 2018-11-21 10:29
 */
public class UtilTest {

    public static void main(String[] args) {
                        //id status carId
        Demo d1 = new Demo(2, 100, 10000);
        Demo d2 = new Demo(5, 200, 30000);
        Demo d3 = new Demo(7, 300, 20000);
        Demo d4 = new Demo(4, 400, 40000);
        Demo d5 = new Demo(10, 500, 50000);

        Demo d6 = new Demo(6, 600, 10000);
        Demo d7 = new Demo(8, 700, 30000);
        Demo d8 = new Demo(3, 800, 20000);
        Demo d9 = new Demo(9, 900, 40000);
        Demo d10 = new Demo(1, 1000, 50000);


        Demo d11 = new Demo(20, 6001, 10000);
        Demo d12 = new Demo(12, 701, 30000);
        Demo d13 = new Demo(15, 801, 20000);
        Demo d14 = new Demo(19, 901, 40000);
        Demo d15 = new Demo(11, 1001, 50000);


        List<Demo> list = new ArrayList(15);
        list.add(d1);
        list.add(d2);
        list.add(d3);
        list.add(d4);
        list.add(d5);

        list.add(d6);
        list.add(d7);
        list.add(d8);
        list.add(d9);
        list.add(d10);

        list.add(d11);
        list.add(d12);
        list.add(d13);
        list.add(d14);
        list.add(d15);
       // Map<Integer, List<Demo>> groupList = list.parallelStream().collect(Collectors.groupingBy(Demo::getCarId));

        //方法1:分组的同时，直接取id最大的那一条记录
        Map<Integer, Demo> m = list.stream().collect(Collectors.groupingBy(Demo::getCarId, Collectors.collectingAndThen(Collectors.toList(), v ->
                v.parallelStream().max(Comparator.comparingInt(Demo::getId)).get()
        )));

        for (Map.Entry<Integer,Demo> entry : m.entrySet()){
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        }

        System.out.println("***************************");


        //方法2:直接转map，用car_id作为key，car_id重复时，取id最大的记录；
        Map<Integer, Demo> groupMap = list.parallelStream().collect(Collectors.toMap(Demo::getCarId, a -> a, (k1, k2) -> k1.id > k2.id ? k1 : k2));
        for (Map.Entry<Integer, Demo> entry : groupMap.entrySet()) {
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        }

        System.out.println("*********************************************************************************");

        //方法3 for循环；

        Map<Integer,Demo> map = new HashMap<>();

        for(int i =0 ;i< list.size();i++){
            Demo demo = list.get(i);
            if(map.get(demo.getCarId()) ==null){
                map.put(demo.getCarId(),demo);
            }
            else{
                if(map.get(demo.getCarId()).getId() < demo.getId()){
                    map.put(demo.getCarId(),demo);
                }
            }
        }
        for (Map.Entry<Integer, Demo> entry : map.entrySet()) {
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        }

    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    static class Demo {
        int id;
        int status;
        int carId;

        @Override
        public String toString() {
            return "Demo{" +
                    "id=" + id +
                    ", status=" + status +
                    ", carId=" + carId +
                    "}";
        }
    }
}