Java8之lambda表達(dá)式

簡(jiǎn)述

Java8發(fā)布了很多的新特性，其中l(wèi)ambda表達(dá)式是一個(gè)重要的部分
（雖然Java11已經(jīng)發(fā)布了 ⊙▽⊙）

1、先來(lái)看一個(gè)新建線程的例子

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(666);
            }
        });

在Thread的構(gòu)造函數(shù)中傳入Runnable實(shí)例，由于Runnable是一個(gè)接口，所以需要實(shí)現(xiàn)其中的抽象方法run

2、改為lambda表達(dá)式后

Thread t1 = new Thread(() -> System.out.println(666));

嘿嘿嘿，是不是異常簡(jiǎn)潔呢？
通過(guò)感性的對(duì)比，我們大致可以發(fā)現(xiàn)，()代表run方法名， 箭頭和后面的語(yǔ)句表示定義整個(gè)方法體。這里我們會(huì)有疑問(wèn)，轉(zhuǎn)換為簡(jiǎn)潔的lambda表達(dá)式需要什么約束呢？下面我們開(kāi)始介紹！

函數(shù)式接口

  • 只有函數(shù)式接口，才可以轉(zhuǎn)換為lambda表達(dá)式，什么是函數(shù)式接口呢？
  • 有且只有一個(gè)抽象方法的接口被成為函數(shù)式接口！
  • 函數(shù)式接口可以顯式的被@FunctionalInterface所表示，當(dāng)被標(biāo)識(shí)的接口不滿足規(guī)定時(shí)，編譯器會(huì)提示報(bào)錯(cuò)

Runnable接口就是一個(gè)函數(shù)式接口

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

轉(zhuǎn)換方式

1、當(dāng)函數(shù)式接口內(nèi)的唯一抽象方法沒(méi)有參數(shù)時(shí)，可以使用如下方式

//如果方法體內(nèi)只有一條語(yǔ)句
//無(wú)返回值
() -> System.out.println("test");
//有返回值，不需要顯示的return
() -> new Student();

//如果有多條語(yǔ)句，需要用{}包圍
//無(wú)返回值
() -> {
    int a = 1;
    int b = 2;
    System.out.println(a * b);
};
//有返回值
() -> {
    int a = 1;
    int b = 2;
    return a * b;
};

2、當(dāng)函數(shù)式接口內(nèi)的唯一抽象方法含有參數(shù)時(shí)，寫(xiě)法與上面基本相同，只是需要把對(duì)應(yīng)參數(shù)寫(xiě)到()里面

//不需要指明參數(shù)類(lèi)型，會(huì)根據(jù)實(shí)際方法中的類(lèi)型自動(dòng)推測(cè)
//只有一個(gè)參數(shù)可以省略括號(hào)
(arg1, arg2, arg3) -> System.out.println(arg1 * arg2 * arg3);

3、舉個(gè)例子

//自定義一個(gè)函數(shù)式接口
@FunctionalInterface
public interface MyInterface {
    void method(int a, int b);
}

    //使用lambda表達(dá)式
    public static void main(String[] args) {
        MyInterface myInterface = (a, b) -> System.out.println(a + b);
        myInterface.method(1, 2);//3
    }

意義

首先毋庸置疑，lambda表達(dá)式十分簡(jiǎn)潔。
其次，在傳統(tǒng)的java面向?qū)ο缶幊讨校覀冊(cè)诜椒▋?nèi)只可以傳遞值或?qū)ο笠茫瑹o(wú)法傳遞方法。
當(dāng)我們想要在方法中傳遞方法，或者說(shuō)是傳遞行為的時(shí)候，如Java Swing或者Android開(kāi)發(fā)中，經(jīng)常需要我們實(shí)現(xiàn)監(jiān)聽(tīng)接口中的方法，這就是一種行為的傳遞。

private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
             //代碼省略
        }
 };

這種行為的傳遞需要依賴接口實(shí)現(xiàn)類(lèi)實(shí)例，但是我們只關(guān)心方法內(nèi)部的邏輯實(shí)現(xiàn)，所以使用lambda表達(dá)式可以實(shí)現(xiàn)這一目標(biāo)

private Handler handler = msg -> {
    //代碼省略
};
//但實(shí)際上lambda并沒(méi)有脫離接口，仍然依附于接口實(shí)現(xiàn)類(lèi)實(shí)例

Java8內(nèi)置的函數(shù)式接口

Java8提供了一個(gè)java.util.function包，包含了很多函數(shù)式接口，我們來(lái)介紹最為基本的4個(gè)（為了節(jié)省篇幅，去掉了源碼中的注釋）

Function接口
@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    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接口的唯一抽象方法是apply，作用是接收一個(gè)指定類(lèi)型的參數(shù)，返回一個(gè)指定類(lèi)型的結(jié)果

import java.util.function.Function;
public class FunctionTest {
    public static void main(String[] args) {
        FunctionTest ft = new FunctionTest();
        //使用lambda表達(dá)式實(shí)現(xiàn)apply方法，返回入?yún)?10。形式上如同傳遞了一個(gè)方法作為參數(shù)
        int res = ft.compute(1, v -> v + 10);
        System.out.println(res);//11
    }

    public int compute(int a, Function<Integer, Integer> function){
        //使用者在使用本方法時(shí)，需要去編寫(xiě)自己的apply，
        //傳遞的funtion是一個(gè)行為方法，而不是一個(gè)值
        return function.apply(a);
    }

默認(rèn)方法compose作用是傳入?yún)?shù)后，首先執(zhí)行compose方法內(nèi)的Function的apply方法，然后將其返回值作為本Function方法的入?yún)ⅲ{(diào)用apply后得到最后返回值

import java.util.function.Function;
public class FunctionTest {
    public static void main(String[] args) {
        FunctionTest ft = new FunctionTest();
        //調(diào)用compose
        //先+8，然后將得到的值*3
        System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//30
    }
    public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2){
        //將function2先接收入?yún)，調(diào)用apply后，將返回值作為新的入?yún)ⅲ瑐魅雈unction1，調(diào)用apply返回最后結(jié)果
        return function1.compose(function2).apply(a);
    }

默認(rèn)方法andThen與compose正好相反，先執(zhí)行本Function的apply，然后將結(jié)果作為andThen方法參數(shù)內(nèi)的Function的入?yún)ⅲ{(diào)用apply后返回最后結(jié)果

import java.util.function.Function;
public class FunctionTest {
    public static void main(String[] args) {
        FunctionTest ft = new FunctionTest();
        //調(diào)用andThen
        //先*3，然后將得到的值+8
        System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//14
    }
    public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2){
        //將function2先接收入?yún)，調(diào)用apply后，將返回值作為新的入?yún)ⅲ瑐魅雈unction1，調(diào)用apply返回最后結(jié)果
        return function1.andThen(function2).apply(a);
    }

靜態(tài)方法identity的作用是傳入啥返回啥，這里就不寫(xiě)例子了

Consumer接口
package java.util.function;

import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Consumer接口中accept方法的作用是接收指定參數(shù)類(lèi)型，無(wú)返回值，重點(diǎn)在于內(nèi)部消費(fèi)

Consumer<String> consumer = s -> System.out.println("hello " + s);
consumer.accept("mike");// hello mike

默認(rèn)方法andThen作用是連續(xù)消費(fèi)，從本Consumer開(kāi)始，從外到內(nèi)，針對(duì)同一入?yún)ⅰ?/p> 

Consumer<String> consumer = s -> System.out.println("hello " + s);
Consumer<String> consumer2 = s -> System.out.println("nice to meet you " + s);
consumer.andThen(consumer2).accept("mike");
//hello mike
//nice to meet you mike
Predicate接口
package java.util.function;

import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

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

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Predicate中的test方法，傳入指定類(lèi)型參數(shù)，返回布爾類(lèi)型的結(jié)果，用于判斷，斷言

//判斷一個(gè)數(shù)是否是偶數(shù)
Predicate<Integer> predicate = b -> n % 2 == 0;
System.out.println(predicate.test(3));
//false

默認(rèn)方法and顧名思義，將本Predicate和and參數(shù)中的Predicate對(duì)同一入?yún)⑦M(jìn)行test的結(jié)果進(jìn)行【與】操作。
negate方法對(duì)test的結(jié)果進(jìn)行【非】操作
or方法對(duì)兩個(gè)Predicate的test結(jié)果進(jìn)行【或】操作

靜態(tài)方法isEqual將其入?yún)⑴ctest方法的入?yún)⑦M(jìn)行equals比較

System.out.println(Predicate.isEqual(1).test(1));//true
Supplier接口
package java.util.function;
@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Supplier意為供應(yīng)，只有一個(gè)方法get，不接收任何參數(shù)，只返回指定類(lèi)型結(jié)果

Supplier<String> sup = () -> "hello world";
System.out.println(sup.get());
總結(jié)

以上就是function包中最為基礎(chǔ)的四個(gè)函數(shù)式接口，不管是接口名稱還是方法名稱，都是見(jiàn)名知意，十分形象。
當(dāng)然funtion包下還有很多其他接口，但基本都與這四個(gè)接口有關(guān)。如BiFunction是接收兩個(gè)參數(shù)，DoubleConsumer是強(qiáng)制接收double類(lèi)型的參數(shù)，更多函數(shù)式接口點(diǎn)進(jìn)去源碼一看注釋便知道如何使用！

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書(shū)系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。