Java8新特性之Lambda表達式(Lambda expressions)

一、Lambda表達式

首先看看在老版本的Java中是如何排列字符串的：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

只需要給靜態方法Collections.sort 傳入一個 List 對象以及一個比較器來按指定順序排列。通常做法都是創建一個匿名的比較器對象然後將其傳遞給 sort 方法。

在Java 8 中你就沒必要使用這種傳統的匿名對象的方式了，Java 8提供了更簡潔的語法，lambda表達式：

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

可以看出，代碼變得更段且更具有可讀性，但是實際上還可以寫得更短：

Collections.sort(names, (String a, String b) -> b.compareTo(a));

對於函數體只有一行代碼的，你可以去掉大括號{}以及return關鍵字，但是你還可以寫得更短點：

names.sort((a, b) -> b.compareTo(a));

List 類本身就有一個 sort 方法。並且Java編譯器可以自動推導出參數類型，所以你可以不用再寫一次類型。接下來我們看看lambda表達式還有什麼其他用法。

二、函數式接口(Functional Interfaces)

注：原文對這部分解釋不太清楚，故做了修改！

Java 語言設計者們投入了大量精力來思考如何使現有的函數友好地支持Lambda。最終採取的方法是：增加函數式接口的概念。“函數式接口”是指僅僅只包含一個抽象方法,但是可以有多個非抽象方法(也就是上面提到的默認方法)的接口。 像這樣的接口，可以被隱式轉換爲lambda表達式。java.lang.Runnable 與 java.util.concurrent.Callable 是函數式接口最典型的兩個例子。Java 8增加了一種特殊的註解@FunctionalInterface,但是這個註解通常不是必須的(某些情況建議使用)，只要接口只包含一個抽象方法，虛擬機會自動判斷該接口爲函數式接口。一般建議在接口上使用@FunctionalInterface 註解進行聲明，這樣的話，編譯器如果發現你標註了這個註解的接口有多於一個抽象方法的時候會報錯的，如下圖所示

示例：

@FunctionalInterface
public interface Converter<F, T> {
  T convert(F from);
}

    // TODO 將數字字符串轉換爲整數類型
    Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
    Integer converted = converter.convert("123");
    System.out.println(converted.getClass()); //class java.lang.Integer

注：大部分函數式接口都不用我們自己寫，Java8都給我們實現好了，這些接口都在java.util.function包裏。

三、方法和構造函數引用(Method and Constructor References)

前一節中的代碼還可以通過靜態方法引用來表示：

    Converter<String, Integer> converter = Integer::valueOf;
    Integer converted = converter.convert("123");
    System.out.println(converted.getClass());   //class java.lang.Integer

Java 8允許您通過::關鍵字傳遞方法或構造函數的引用。上面的示例顯示瞭如何引用靜態方法。但我們也可以引用對象方法：

class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}

Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

接下來看看構造函數是如何使用::關鍵字來引用的，首先我們定義一個包含多個構造函數的簡單類：

class Person {
    String firstName;
    String lastName;

    Person() {}

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

接下來我們指定一個用來創建Person對象的對象工廠接口：

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

這裏我們使用構造函數引用來將他們關聯起來，而不是手動實現一個完整的工廠：

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

我們只需要使用 Person::new 來獲取Person類構造函數的引用，Java編譯器會自動根據PersonFactory.create方法的參數類型來選擇合適的構造函數。

四、Lamda 表達式作用域(Lambda Scopes)

訪問局部變量

我們可以直接在 lambda 表達式中訪問外部的局部變量：

final int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3

但是和匿名對象不同的是，這裏的變量num可以不用聲明爲final，該代碼同樣正確：

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3

不過這裏的 num 必須不可被後面的代碼修改（即隱性的具有final的語義），例如下面的就無法編譯：

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
num = 3;//在lambda表達式中試圖修改num同樣是不允許的。

訪問字段和靜態變量

與局部變量相比，我們對lambda表達式中的實例字段和靜態變量都有讀寫訪問權限。該行爲和匿名對象是一致的。

class Lambda4 {
    static int outerStaticNum;
    int outerNum;

    void testScopes() {
        Converter<Integer, String> stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };

        Converter<Integer, String> stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }
}

訪問默認接口方法

還記得第一節中的 formula 示例嗎？ Formula 接口定義了一個默認方法sqrt，可以從包含匿名對象的每個 formula 實例訪問該方法。這不適用於lambda表達式。

無法從 lambda 表達式中訪問默認方法,故以下代碼無法編譯：

Formula formula = (a) -> sqrt(a * 100);

五、內置函數式接口(Built-in Functional Interfaces)

JDK 1.8 API包含許多內置函數式接口。其中一些藉口在老版本的 Java 中是比較常見的比如： Comparator 或Runnable，這些接口都增加了@FunctionalInterface註解以便能用在 lambda 表達式上。

但是 Java 8 API 同樣還提供了很多全新的函數式接口來讓你的編程工作更加方便，有一些接口是來自 Google Guava 庫裏的，即便你對這些很熟悉了，還是有必要看看這些是如何擴展到lambda上使用的。

Predicates

Predicate 接口是隻有一個參數的返回布爾類型值的 斷言型 接口。該接口包含多種默認方法來將 Predicate 組合成其他複雜的邏輯（比如：與，或，非）：

注： Predicate 接口源碼如下

package java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface Predicate<T> {
    
    // 該方法是接受一個傳入類型,返回一個布爾值.此方法應用於判斷.
    boolean test(T t);

    //and方法與關係型運算符"&&"相似，兩邊都成立才返回true
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    // 與關係運算符"!"相似，對判斷進行取反
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    //or方法與關係型運算符"||"相似，兩邊只要有一個成立就返回true
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
   // 該方法接收一個Object對象,返回一個Predicate類型.此方法用於判斷第一個test的方法與第二個test方法相同(equal).
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

示例：

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();

Functions

Function 接口接受一個參數並生成結果。默認方法可用於將多個函數鏈接在一起（compose, andThen）：

注： Function 接口源碼如下


package java.util.function;
 
import java.util.Objects;
 
@FunctionalInterface
public interface Function<T, R> {
    
    //將Function對象應用到輸入的參數上，然後返回計算結果。
    R apply(T t);
    //將兩個Function整合，並返回一個能夠執行兩個Function對象功能的Function對象。
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    // 
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
 
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

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

Suppliers

Supplier 接口產生給定泛型類型的結果。與 Function 接口不同，Supplier 接口不接受參數。

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person

Consumers

Consumer 接口表示要對單個輸入參數執行的操作。

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

Comparators

Comparator 是老Java中的經典接口， 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

更多關於函數式接口的詳解這篇博客寫的很好，就不再贅述了：JDK8函數式接口Function、Consumer、Predicate、Supplier

Java8新特性之Lambda表達式(Lambda expressions)

目錄

一、Lambda表達式

二、函數式接口(Functional Interfaces)

三、方法和構造函數引用(Method and Constructor References)

四、Lamda 表達式作用域(Lambda Scopes)

訪問局部變量

訪問字段和靜態變量

訪問默認接口方法

五、內置函數式接口(Built-in Functional Interfaces)

Predicates

Functions

Suppliers

Consumers

Comparators

EXCEL中下拉菜單中添加新選項或者刪除選項

號稱能打敗MLP的KAN到底行不行？數學核心原理全面解析

同事使用 insert into select 遷移數據，開開心心上線，上線後被公司開除！

Git使用經驗總結5-修改提交信息

Python 爬蟲：Spring Boot 反爬蟲的成功案例

京東科技數字化營銷能力的演進與最佳實踐| 京東雲技術團隊

Git使用經驗總結4-撤回上一次本地提交

Java中止線程的方式

壓榨數據庫的真實處理速度

[轉帖]Oracle Exadata 學習筆記之核心特性Part1

Java8新特性之Streams和Parallel Streams

什麼是微服務、微服務架構

分佈式系統常見負載均衡算法及其nginx實現

爲什麼要使用多線程?

sleep() 方法和 wait() 方法區別和共同點

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結