Lambda擴充套件與用途

1、內建的函式式介面

    JDK 1.8 API 包含了很多內建的函式式介面。其中就包括我們在老版本中經常見到的 Comparator 和 Runnable，Java 8 為他們都新增了 @FunctionalInterface 註解，以用來支援 Lambda 表示式。

    值得一提的是，除了 Comparator 和 Runnable 外，還有一些新的函式式介面，它們很多都借鑑於知名的 Google Guava 庫。

(1). Predicate 斷言

    Predicate 是一個可以指定入參型別，並返回 boolean 值的函式式介面。它內部提供了一些帶有預設實現的方法，可以被用來組合一個複雜的邏輯判斷（ and, or,negate）

    Predicate<String> predicate = (s) -> s.length() > 0;

    predicate.test("foo");              // true
    predicate.negate().test("foo");     // false

    Predicate<Boolean> nonNull = Objects::nonNull;
    Predicate<Boolean> isNull = Objects::isNull;

    Predicate<String> isEmpty = String::isEmpty;
    Predicate<String> isNotEmpty = isEmpty.negate();
複製程式碼

(2). Function

    Function 函式式介面的作用是，我們可以為其提供一個原料，他給生產一個最終的產品。通過它提供的預設方法，組合,鏈行處理( compose, andThen)：

    Function<String, Integer> toInteger = Integer::valueOf;
    Function<String, String> backToString = toInteger.andThen(String::valueOf);

    backToString.apply("123");     // "123"
複製程式碼

(3). Supplier 生產者

    Supplier 與 Function 不同，它不接受入參，直接為我們生產一個指定的結果，有點像生產者模式：

    class Person {
        String firstName;
        String lastName;

        Person() {}

        Person(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }

    Supplier<Person> personSupplier = Person::new;
    personSupplier.get();   // new Person
複製程式碼

(4). Consumer 消費者

    對於 Consumer，我們需要提供入參，用來被消費，如下面這段示例程式碼：

    class Person {
        String firstName;
        String lastName;

        Person() {}

        Person(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }


    Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
    greeter.accept(new Person("Luke", "Skywalker"));
複製程式碼

(5). Comparator

    Comparator 在 Java 8 之前是使用比較普遍的。Java 8 中除了將其升級成了函式式介面，還為它擴充了一些預設方法：

    Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);

    Person p1 = new Person("John", "Doe");
    Person p2 = new Person("Alice", "Wonderland");

    comparator.compare(p1, p2);             // > 0
    comparator.reversed().compare(p1, p2);  // < 0
複製程式碼

(6). Optional

    首先， Optional 它不是一個函式式介面，設計它的目的是為了防止空指標異常（ NullPointerException），要知道在 Java 程式設計中，空指標異常可是臭名昭著的。
    讓我們來快速瞭解一下 Optional 要如何使用！你可以將 Optional 看做是包裝物件（可能是 null, 也有可能非 null）的容器。當你定義了一個方法，這個方法返回的物件可能是空，也有可能非空的時候，你就可以考慮用 Optional 來包裝它，這也是在 Java 8 被推薦使用的做法。

    Optional<String> optional = Optional.of("bam");

    optional.isPresent();           // true
    optional.get();                 // "bam"
    optional.orElse("fallback");    // "bam"

    optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"
複製程式碼

2、Map 集合

    前面已經提到過 Map 是不支援 Stream 流的，因為 Map 介面並沒有像 Collection 介面那樣，定義了 stream() 方法。但是，我們可以對其 key, values, entry 使用流操作，如 map.keySet().stream(), map.values().stream() 和 map.entrySet().stream().
    另外, JDK 8 中對 map 提供了一些其他新特性:

    Map<Integer, String> map = new HashMap<>();
    for (int i = 0; i < 10; i++) {
        // 與老版不同的是，putIfAbent() 方法在 put 之前，會判斷 key 是否已經存在，
        //存在則直接返回 value, 否則 put, 再返回 value
        map.putIfAbsent(i, "val" + i);
    }

    // forEach 可以很方便地對 map 進行遍歷操作
    map.forEach((key, value) -> System.out.println(value));
複製程式碼

    除了上面的 putIfAbsent() 和 forEach() 外，還可以很方便地對某個 key 的值做相關操作：

    // computeIfPresent(), 當 key 存在時，才會做相關處理  如下：對 key 為 3 的值，
    //內部會先判斷值是否存在，存在，則做 value + key 的拼接操作
    map.computeIfPresent(3, (num, val) -> val + num);
    map.get(3);             // val33

    // 先判斷 key 為 9 的元素是否存在，存在，則做刪除操作
    map.computeIfPresent(9, (num, val) -> null);
    map.containsKey(9);     // false

    // computeIfAbsent(), 當 key 不存在時，才會做相關處理  如下：先判斷 key 為 23 的元素是否存在，
    //不存在，則新增
    map.computeIfAbsent(23, num -> "val" + num);
    map.containsKey(23);    // true

    // 先判斷 key 為 3 的元素是否存在，存在，則不做任何處理
    map.computeIfAbsent(3, num -> "bam");
    map.get(3);             // val33
複製程式碼

    關於刪除操作，JDK 8 中提供了能夠新的 remove() API:

    map.remove(3, "val3");
    map.get(3);             // val33

    map.remove(3, "val33");
    map.get(3);             // null
    
    如上程式碼，只有當給定的 key 和 value 完全匹配時，才會執行刪除操作。
複製程式碼

    關於新增方法，JDK 8 中提供了帶有預設值的 getOrDefault() 方法：

    // 若 key 42 不存在，則返回 not found
    map.getOrDefault(42, "not found");  // not found
複製程式碼

    對於 value 的合併操作也變得更加簡單：

    // merge 方法，會先判斷進行合併的 key 是否存在，不存在，則會新增元素
    map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9

    // 若 key 的元素存在，則對 value 執行拼接操作
    map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9concat
複製程式碼

作者：xxx
連結：xxx
來源：xxx
複製程式碼

3、Map 操作之 merge()

3.1、merge()用法

    有一個學生成績物件的列表，物件包含學生姓名、科目、科目分數三個屬性，要求求得每個學生的總成績。加入列表如下：

private List<StudentScore> buildATestList() {
    List<StudentScore> studentScoreList = new ArrayList<>();
    StudentScore studentScore1 = new StudentScore() {{
        setStuName("張三");
        setSubject("語文");
        setScore(70);
    }};
    StudentScore studentScore2 = new StudentScore() {{
        setStuName("張三");
        setSubject("數學");
        setScore(80);
    }};
    StudentScore studentScore3 = new StudentScore() {{
        setStuName("張三");
        setSubject("英語");
        setScore(65);
    }};
    StudentScore studentScore4 = new StudentScore() {{
        setStuName("李四");
        setSubject("語文");
        setScore(68);
    }};
    StudentScore studentScore5 = new StudentScore() {{
        setStuName("李四");
        setSubject("數學");
        setScore(70);
    }};
    StudentScore studentScore6 = new StudentScore() {{
        setStuName("李四");
        setSubject("英語");
        setScore(90);
    }};
    StudentScore studentScore7 = new StudentScore() {{
        setStuName("王五");
        setSubject("語文");
        setScore(80);
    }};
    StudentScore studentScore8 = new StudentScore() {{
        setStuName("王五");
        setSubject("數學");
        setScore(85);
    }};
    StudentScore studentScore9 = new StudentScore() {{
        setStuName("王五");
        setSubject("英語");
        setScore(70);
    }};

    studentScoreList.add(studentScore1);
    studentScoreList.add(studentScore2);
    studentScoreList.add(studentScore3);
    studentScoreList.add(studentScore4);
    studentScoreList.add(studentScore5);
    studentScoreList.add(studentScore6);
    studentScoreList.add(studentScore7);
    studentScoreList.add(studentScore8);
    studentScoreList.add(studentScore9);

    return studentScoreList;
}

===================常規做法===================
    ObjectMapper objectMapper = new ObjectMapper();
    List<StudentScore> studentScoreList = buildATestList();

    Map<String, Integer> studentScoreMap = new HashMap<>();
    studentScoreList.forEach(studentScore -> {
        if (studentScoreMap.containsKey(studentScore.getStuName())) {
            studentScoreMap.put(studentScore.getStuName(), 
                studentScoreMap.get(studentScore.getStuName()) + studentScore.getScore());
        } else {
            studentScoreMap.put(studentScore.getStuName(), studentScore.getScore());
        }
    });

    System.out.println(objectMapper.writeValueAsString(studentScoreMap));
    // 結果如下：{"李四":228,"張三":215,"王五":235}
    
===================merge()做法===================
    Map<String, Integer> studentScoreMap2 = new HashMap<>();
    studentScoreList.forEach(studentScore -> studentScoreMap2.merge(
        studentScore.getStuName(),
        studentScore.getScore(),
        Integer::sum));

    System.out.println(objectMapper.writeValueAsString(studentScoreMap2));
    // 結果如下：{"李四":228,"張三":215,"王五":235}
複製程式碼

3.2、merge()簡介

    merge() 可以這麼理解：它將新的值賦值到 key （如果不存在）或更新給定的key 值對應的 value，其原始碼如下：

default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) 
{
    Objects.requireNonNull(remappingFunction);
    Objects.requireNonNull(value);
    V oldValue = this.get(key);
    V newValue = oldValue == null ? value : remappingFunction.apply(oldValue, value);
    if (newValue == null) {
        this.remove(key);
    } else {
        this.put(key, newValue);
    }

    return newValue;
}

我們可以看到原理也是很簡單的，該方法接收三個引數，
一個 key 值，一個 value，一個 remappingFunction ，
如果給定的key不存在，它就變成了 put(key, value) 。
如果 key 已經存在一些值，我們 remappingFunction 可以選擇合併的方式，
    然後將合併得到的 newValue 賦值給原先的 key。
複製程式碼

3.2、使用場景

    這個使用場景相對來說還是比較多的，比如分組求和這類的操作，雖然 stream 中有相關 groupingBy() 方法，但如果你想在迴圈中做一些其他操作的時候，merge() 還是一個挺不錯的選擇的。

3.3、其他

    除了 merge() 方法之外，我還看到了一些Java 8 中 map 相關的其他方法，比如 putIfAbsent 、compute() 、computeIfAbsent() 、computeIfPresent，這些方法我們看名字應該就知道是什麼意思了，故此處就不做過多介紹了，感興趣的可以簡單閱讀一下原始碼（都還是挺易懂的），這裡我們貼一下 compute()(Map.class) 的原始碼，其返回值是計算後得到的新值：

default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    Objects.requireNonNull(remappingFunction);
    V oldValue = this.get(key);
    V newValue = remappingFunction.apply(key, oldValue);
    if (newValue == null) {
        if (oldValue == null && !this.containsKey(key)) {
            return null;
        } else {
            this.remove(key);
            return null;
        }
    } else {
        this.put(key, newValue);
        return newValue;
    }
}
複製程式碼

3.4、總結

    本文簡單介紹了一下 Map.merge() 的方法，除此之外，Java 8 中的 HashMap 實現方法使用了 TreeNode 和 紅黑樹，在原始碼閱讀上可能有一點難度，不過原理上還是相似的，compute() 同理。所以，原始碼肯定是要看的，不懂的地方多讀多練自然就理解了。

參考：https://www.jianshu.com/p/68e6b30410b0

程式碼地址：https://github.com/lq920320/algorithm-java-test/blob/master/src/test/java/other/MapMethodsTest.java
複製程式碼

作者：LQ木頭
連結：juejin.im/post/5d9b455ae51d45782b0c1bfb
來源：掘金
複製程式碼