AFansGH
diff --git a/Collapse file
‎JdkLearn/src/main/java/com/learnjava/lambda/LambdaComparatorDemo.java‎
Copy file name to clipboardExpand all lines: JdkLearn/src/main/java/com/learnjava/lambda/LambdaComparatorDemo.java
+4-4Lines changed: 4 additions & 4 deletions b/Collapse file
‎JdkLearn/src/main/java/com/learnjava/lambda/LambdaComparatorDemo.java‎
Copy file name to clipboardExpand all lines: JdkLearn/src/main/java/com/learnjava/lambda/LambdaComparatorDemo.java
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/Collapse file
‎JdkLearn/src/main/java/com/learnjava/lambda/LambdaMapDemo.java‎
Copy file name to clipboardExpand all lines: JdkLearn/src/main/java/com/learnjava/lambda/LambdaMapDemo.java
+98-3Lines changed: 98 additions & 3 deletions b/Collapse file
‎JdkLearn/src/main/java/com/learnjava/lambda/LambdaMapDemo.java‎
Copy file name to clipboardExpand all lines: JdkLearn/src/main/java/com/learnjava/lambda/LambdaMapDemo.java
+98-3Lines changed: 98 additions & 3 deletions
@@ -21,11 +21,11 @@ public class LambdaComparatorDemo {
     static {
         Employee e1 = new Employee(1,23,"M","Rick","Beethovan", "2021-04-01");
         Employee e2 = new Employee(2,13,"F","Martina","Hengis", "2021-04-02");
-        Employee e3 = new Employee(3,43,"M","Ricky","Martin","2021-04-03" );
-        Employee e4 = new Employee(4,26,"M","Jon","Lowman", "2021-04-04");
-        Employee e5 = new Employee(5,19,"F","Cristine","Maria", "2021-04-05");
+        Employee e3 = new Employee(3,43,"M","Ricky","Martin","2021-04-09" );
+        Employee e4 = new Employee(4,26,"M","Jon","Lowman", "2021-04-10");
+        Employee e5 = new Employee(5,19,"F","Cristine","Maria", "2021-04-01");
         Employee e6 = new Employee(6,15,"M","David","Feezor", "2021-04-06");
-        Employee e7 = new Employee(7,68,"F","Melissa","Roy", "2021-04-07");
+        Employee e7 = new Employee(7,68,"F","Melissa","Roy", "2021-04-06");
         Employee e8 = new Employee(8,79,"M","Alex","Gussin", "2021-04-08");
         Employee e9 = new Employee(9,15,"F","Neetu","Singh", "2021-04-09");
         Employee e10 = new Employee(10,45,"M","Naveen","Jain", "2021-04-10");
 
@@ -1,8 +1,8 @@
 package com.learnjava.lambda;
 
 import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
@@ -14,7 +14,10 @@ public class LambdaMapDemo {
     public static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
 
     public static void main(String[] args) {
-        test01();
+//        test01();
+//        test02();
+//        test03();
+        test04();
     }
 
     /**
@@ -23,6 +26,7 @@ public static void main(String[] args) {
     public static void test01() {
         List<LambdaComparatorDemo.Employee> sortedByDate = LambdaComparatorDemo.employees
                 .stream()
+                .sorted()
                 .sorted((a, b) -> {
                     int result;
                     try {
@@ -36,6 +40,97 @@ public static void test01() {
         System.out.println(sortedByDate);
     }
 
+    /**
+     * HashMap的merge方法，如果key相同，则通过merge来对key相同的袁术进行处理
+     */
+    public static void test02() {
+        String key = "money";
+        Map<String, Integer> map = new HashMap<String, Integer>(){{put(key, 100);}};
+
+        // 第三个参数时BiFunction，聚合函数（可以这么理解）
+        map.merge(key,100,(oldValue, newValue) -> oldValue + newValue);
+//        map.merge(key, 100,Integer::sum);
+        System.out.println(map);
+    }
+
+    /**
+     * 对map进行排序
+     */
+    public static void test03() {
+        Map<String, Integer> codes = new HashMap<>();
+        codes.put("2021-04-01", 1);
+        codes.put("2021-04-15", 49);
+        codes.put("2021-04-10", 33);
+        codes.put("2021-04-05", 86);
+        codes.put("2021-04-20", 92);
+
+        // 先将Map转化为List，通过collect处理后再转为Map
+        Map<String, Integer> sortedMap = codes.entrySet()
+                .stream()
+//                .sorted((c1, c2) -> c2.getValue().compareTo(c1.getValue()))
+//                .sorted(Map.Entry.comparingByValue())
+                .sorted((c1, c2) -> c2.getKey().compareTo(c1.getKey()))
+                .collect(
+                        Collectors.toMap(
+                                Map.Entry::getKey,
+                                Map.Entry::getValue,
+                                (oldVal, newVal) -> oldVal,
+                                LinkedHashMap::new
+                        )
+                );
+
+        sortedMap.entrySet().forEach(System.out::println);
+
+    }
+
+    /**
+     * 将list转为map，并用其中一个value作为key
+     */
+    public static void test04() {
+        LinkedHashMap<String, LambdaComparatorDemo.Employee> collect = LambdaComparatorDemo.employees
+                .stream()
+                .collect(
+                        Collectors.toMap(
+                                LambdaComparatorDemo.Employee::getDate,
+                                // 这样是返回本身对象的一个表达式，还可以用Function.identity()
+                                // Function.indentity() 就是 t -> t
+//                                employee -> employee,
+                                Function.identity(),
+                                (oldVal, newVal) -> {
+                                    // 重复的key就将年纪相加，然后FirstName通过--->加起来
+                                    oldVal.setAge(oldVal.getAge() + newVal.getAge());
+                                    oldVal.setFirstName(oldVal
+                                            .getFirstName()
+                                            .concat("--->")
+                                            .concat(newVal.getFirstName()));
+                                    return oldVal;
+                                },
+                                LinkedHashMap::new
+                        )
+                );
+        // 这样打印出的map元素不好观察
+//        System.out.println(collect);
+//        collect.entrySet().forEach(System.out::println);
+
+        LinkedHashMap<String, LambdaComparatorDemo.Employee> sortedCollect = collect
+                .entrySet()
+                .stream()
+                .sorted((a, b) -> b.getKey().compareTo(a.getKey()))
+                .collect(
+                        Collectors.toMap(
+                                Map.Entry::getKey,
+                                Map.Entry::getValue,
+                                // 上面已经对重复key做处理了，这里就直接范围oldVal就行
+                                (oldVal, newVal) -> oldVal,
+                                LinkedHashMap::new
+                        )
+                );
+
+        // 根据日期排序
+        sortedCollect.entrySet()
+                .forEach(System.out::println);
+    }
+
     public static Date getDate(String date) throws Exception {
         return format.parse(date);
     }