[[415968]]

前言

Lambda語法在Java中已經(jīng)被廣泛的運(yùn)用，我們在開發(fā)Android中幾乎上每一個項(xiàng)目也會在項(xiàng)目中接入Lambda插件，因?yàn)長ambda確實(shí)能簡少很多的代碼量。

無獨(dú)有偶，在Kotlin中也是Lambda語法的，在這篇文章中就詳細(xì)的為大家講解Lambda語法的編寫與使用

一、kotin高階函數(shù)詳解

1、高階函數(shù)是將函數(shù)用作參數(shù)或返回值的函數(shù)。這種函數(shù)的一個很好的例子是 lock()，它接受一個鎖對象和一個函數(shù)，獲取鎖，運(yùn)行函數(shù)并釋放鎖：

fun <T> lock(lock: Lock, body: () -> T): T { 
    lock.lock() 
    try { 
        return body() 
    } 
    finally { 
        lock.unlock() 
    } 
} 

body 擁有函數(shù)類型：() -> T，所以它應(yīng)該是一個不帶參數(shù)并且返回 T 類型值的函數(shù)。它在 try{: .keyword }-代碼塊內(nèi)部調(diào)用、被 lock 保護(hù)，其結(jié)果由lock()函數(shù)返回。如果我們想調(diào)用lock()函數(shù)，我們可以把另一個函數(shù)傳給它作為參數(shù)(參見函數(shù)引用)

2、如果一個函數(shù)接收另一個函數(shù)作為參數(shù)，或者返回值的類型是另一個函數(shù)，那么該函數(shù)就稱為高階函數(shù)

函數(shù)類型，基本規(guī)則如下：

(String,Int) -> Unit

現(xiàn)在將上述函數(shù)類型添加到某個函數(shù)的參數(shù)聲明或者返回值聲明上，那么這個函數(shù)就是一個高階函數(shù)了，例如

fun example(func: (String, Int) -> Unit) {

func("hello", 123)

}

可以看到這里的 example() 函數(shù)接收到了一個函數(shù)類型參數(shù)，因此 example() 函數(shù)就是一個高階函數(shù);

這里我準(zhǔn)備定義一個叫作 num1AndNum2() 的高階函數(shù)，讓它接收兩個整形和一個函數(shù)類型的參數(shù)。我們會在 num1AndNum2() 函數(shù)中對傳入的兩個整型參數(shù)進(jìn)行某種運(yùn)算，并返回運(yùn)行結(jié)果。但具體進(jìn)行什么運(yùn)算是由傳入的函數(shù)類型參數(shù)決定的

新建一個名為 Test1.kt 文件

fun num1AndNum2(num1:Int,num2:Int,operation:(Int,Int)->Int):Int{ 
    val result = operation(num1,num2) 
    return result 
} 
fun plus(num1: Int, num2: Int): Int { 
    return num1 + num2 
} 
fun minus(num1: Int, num2: Int): Int { 
    return num1 - num2 
} 
 main() 函數(shù) 
fun main(){ 
    val num1 = 100 
    val num2 = 80 
    val result1 = num1AndNum2(num1,num2, ::plus) 
    val result2 = num1AndNum2(num1,num2,::minus) 
    println("result1:"+result1) 
    println("result2:"+result2) 
} 
result1:180 
result1:20 

::plus 和 ::minus 的寫法，這是一種函數(shù)引用方式的寫法，表示將 plus() 和 minus() 函數(shù)作為參數(shù)傳遞給 num1AndNum2() 函數(shù)

如果每次調(diào)用任何高階函數(shù)時都還得先定義一個與其函數(shù)類型參數(shù)相匹配的函數(shù)，是不是太復(fù)雜了?沒錯，因此 Kotlin 還支持其他多種方式來調(diào)用高階函數(shù)，比如 Lambda 表達(dá)式、匿名函數(shù)、成員引用等。其中 Lambda 表達(dá)式是最常見也是最普遍的高階函數(shù)調(diào)用方式，剛才的代碼使用 Lambda 表達(dá)式來實(shí)現(xiàn)(Lambda 表達(dá)式最后一行自動作為返回值)，plus() 和 minus() 函數(shù)可以刪掉了

fun main() { 
    val num1 = 100 
    val num2 = 80 
    val result1 = num1AndNum2(num1, num2) { n1, n2 -> 
        n1 + n2 
    } 
    val result2 = num1AndNum2(num1, num2) { n1, n2 -> 
        n1 - n2 
    } 
    println("result1:" + result1) 
    println("result2:" + result2) 
} 
fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int { 
    val result = operation(num1, num2) 
    return result 
} 

3、閉包函數(shù)

閉包函數(shù) 一個函數(shù)的返回值是函數(shù)，函數(shù)的內(nèi)部包含另一個函數(shù)，可以是有參無參的匿名函數(shù)

fun main(args: Array<String>) { 
    val mm = aaa() 
    println(mm()) 
    println(mm()) 
    println(mm()) 
    println(mm()) 
    println(mm()) 
    val  kk = bbb() 
    println(kk("shadow")) //shadow --- 1 
    println(kk("shadow")) //shadow --- 2 
    println(kk("shadow")) //shadow --- 3 
    println(kk("shadow")) //shadow --- 4 
    println(kk("shadow")) //shadow --- 5 
} 
//閉包函數(shù) 就是函數(shù)作為返回參數(shù) 
fun aaa(): () -> (Int) { 
    var current = 10 
    return fun(): Int { 
        return current++ 
    } 
} 
fun bbb(): (String) -> (String) { 
    var current = 0; 
    return fun(str: String): String { 
        current++; 
        return "$str --- $current"; 
    } 
} 

4、kotin中高階函數(shù)案例

map 變換

fun main(args: Array<String>) { 
    val list = listOf(1, 2, 3, 4, 5, 6) 
    val newList = list.map { 
        //對集合中的數(shù)據(jù)進(jìn)行操作，然后賦值給新的集合 
        (it * 2).toString() 
    }.forEach(::println) //2 4 6 8 10 12 
    val doubleList = list.map { 
        it.toDouble() 
    }.forEach(::print) //1.0 2.0 3.0 4.0 5.0 6.0 
    //函數(shù)作為參數(shù)的第二種方式調(diào)用 類名::方法名 
    val doubleList2 = list.map(Int::toDouble).forEach(::print) ////1.0 2.0 3.0 4.0 5.0 6.0 
} 

flatMap 對集合的集合進(jìn)行變換

fun main(args: Array<String>) { 
    val list = arrayOf( 
        1..5, 
        50..55 
    ) 
    //把多個數(shù)組集合變成一個數(shù)組，并且對數(shù)據(jù)進(jìn)行變換 
    val mergeList = list.flatMap { intRange -> //集合內(nèi)的集合 1..5 , 50..55 
        intRange.map { intElement -> //集合內(nèi)集合遍歷 1,2,3,4,5 
            "No.$intElement" 
        } 
    } 
    //No.1 , No.2 , No.3 , No.4 , No.5 , No.50 , No.51 , No.52 , No.53 , No.54 , No.55 , 
    mergeList.forEach { print("$it , ") } 
    println() 
    //直接多個數(shù)組集合變換成一個結(jié)集合 
    val newList = list.flatMap { 
        it 
    } 
    //1 , 2 , 3 , 4 , 5 , 50 , 51 , 52 , 53 , 54 , 55 , 
    newList.forEach { print("$it , ") } 
} 

filter 篩選

fun main(args: Array<String>) { 
    val list = arrayOf( 
        1..5, 
        2..3 
    ) 
    val newList = list.flatMap { 
        it 
    } 
    //篩選 集合中數(shù)據(jù) > 2的item 
    val filterList = newList.filter { it > 2 } 
    filterList.forEach(::print) //3453 
    //篩選 集合中下標(biāo)是奇數(shù)item 
    val filterIndexList = newList.filterIndexed { index, i -> index % 2 == 0; } 
    filterIndexList.forEach { print(it) } //1 3 5 3 
} 

forEach

fun main(args: Array<String>) { 
    var list = listOf(1, 2, 3, 4, 5, 6) 
    list.forEach(::println) 
    val newList = arrayListOf<String>() --->1,2,3,4,5,6 
    list.forEach { 
        newList.add((it * 2).toString()) --->2,4,6,8,10,12 
    } 
    newList.forEach(::println) 
} 

下面我們就來介紹Lambda

二、Lambda表達(dá)式詳解

1、Lambda表達(dá)式是什么?

• Lambda表達(dá)式是JDK8推出一個重要的新特性，雖然看著很高大上，其實(shí)Lambda表達(dá)式的本質(zhì)只是一個”語法糖”，習(xí)慣了面向?qū)ο缶幊痰乃枷耄婚_始看起來會有點(diǎn)不習(xí)慣這種語法形式，但如果你學(xué)過C#，你就會發(fā)現(xiàn)語法和C#中的“委托”很像;
• 大家都知道，在Java中萬物皆對象，Java 一直都致力維護(hù)其對象至上的特征，函數(shù)對 Java 而言雖然重要，但在 Java 的世界里，函數(shù)無法獨(dú)立存在，只能依賴于對象來調(diào)用。在函數(shù)式編程語言中，函數(shù)是一等公民，它們可以獨(dú)立存在，你可以將其賦值給一個變量，或?qū)⑺麄儺?dāng)做參數(shù)傳給其他函數(shù)。JavaScript 就是函數(shù)式編程語言最典型的代表;
• 函數(shù)式語言提供了一種強(qiáng)大的功能——閉包，相比于傳統(tǒng)的編程方法有很多優(yōu)勢，閉包是一個可調(diào)用的對象，它記錄了一些信息，這些信息來自于創(chuàng)建它的作用域。因此Java 現(xiàn)在提供的最接近閉包的概念便是 Lambda 表達(dá)式，雖然閉包與 Lambda 表達(dá)式之間存在顯著差別，但至少 Lambda 表達(dá)式是閉包很好的替代者;
• 使用Lambda表達(dá)式的目的就是取代大部分的匿名內(nèi)部類，讓我們能寫出更簡潔優(yōu)雅的 Java 代碼，尤其在集合的遍歷和其他集合操作中，可以極大地優(yōu)化代碼結(jié)構(gòu)。JDK 也提供了大量的內(nèi)置函數(shù)式接口供我們使用，使得 Lambda 表達(dá)式的運(yùn)用更加方便、高效;
• 如果在你沒有熟練掌握Lambda表達(dá)式時，不建議亂用，因?yàn)椴皇褂肔ambda表達(dá)式，你同樣可以實(shí)現(xiàn)相應(yīng)功能，只把它當(dāng)做一種錦上添花的工具就可以了;

2、Lambda表達(dá)式語法結(jié)構(gòu)

Lambda表達(dá)式基礎(chǔ)語法結(jié)構(gòu)如下：

(parameters) -> expression 
或 
(parameters) ->{ statements; } 

其中 () 用來描述參數(shù)列表，{} 用來描述方法體，-> 為 lambda運(yùn)算符 ，讀作(goes to)，parameters表示參數(shù)，expression表示表達(dá)式，statements表示代碼塊。

結(jié)構(gòu)說明如下：

一個 Lambda 表達(dá)式可以有零個或多個參數(shù)

參數(shù)的類型既可以明確聲明，也可以根據(jù)上下文來推斷。

例如：

(int a)與(a)效果相同

所有參數(shù)需包含在圓括號內(nèi)，參數(shù)之間用逗號相隔。

例如：

(a, b) 或 (int a, int b) 或 (String a, int b, float c) 

空圓括號代表參數(shù)集為空。例如：() -> 42

當(dāng)只有一個參數(shù)，且其類型可推導(dǎo)時，圓括號()可省略。

例如：a -> return a*a

Lambda 表達(dá)式的主體可包含零條或多條語句

如果 Lambda 表達(dá)式的主體只有一條語句，花括號{}可省略。匿名函數(shù)的返回類型與該主體表達(dá)式一致;

如果 Lambda 表達(dá)式的主體包含一條以上語句，則表達(dá)式必須包含在花括號{}中(形成代碼塊)。匿名函數(shù)的返回類型與代碼塊的返回類型一致，若沒有返回則為空;

3、Lambda表達(dá)式重要特征

• 可選類型聲明：不需要聲明參數(shù)類型，編譯器可以統(tǒng)一識別參數(shù)值。
• 可選的參數(shù)圓括號：一個參數(shù)無需定義圓括號，但多個參數(shù)需要定義圓括號。
• 可選的大括號：如果主體包含了一個語句，就不需要使用大括號。
• 可選的返回關(guān)鍵字：如果主體只有一個表達(dá)式返回值則編譯器會自動返回值，大括號需要指定明表達(dá)式返回了一個數(shù)值。

4、函數(shù)式接口詳解

①什么是函數(shù)式接口

函數(shù)式接口在java中是指只有一個抽象方法的接口。

函數(shù)式接口，就是適用于函數(shù)式編程場景的接口。在java中函數(shù)式編程就體現(xiàn)在Lambda，因此函數(shù)式接口就是能夠適用于lambda使用的接口。只有確保接口中有且僅有一個抽象方法，lambda才能進(jìn)行順利的推導(dǎo);

②語法

@FunctionalInterface注解

注解和@override注解的作用類似。該住處應(yīng)用于函數(shù)式接口的定義上。

一旦使用了該注解來定義函數(shù)式接口，編譯器就會檢查該接口是否是有且僅有一個抽象方法

@FunctionalInterface 
public interface MyFunctionalInterface { 
      void myMethod(); 
} 
將函數(shù)式接口作為方法的參數(shù) 
public class Demo { 
    private static void dos(FunctionInterface fi){ 
        fi.method(); 
    } 
    public static void main(String[] args) { 
        Demo.dos(()->{System.out.println("lambda表達(dá)式");}); 
    } 

5、Lambda表達(dá)式基本使用案例

表達(dá)式基本使用案例

// 1. 不需要參數(shù),返回值為 5   
() -> 5   
// 2. 接收一個參數(shù)(數(shù)字類型),返回其2倍的值   
x -> 2 * x   
// 3. 接受2個參數(shù)(數(shù)字),并返回他們的差值   
(x, y) -> x – y   
// 4. 接收2個int型整數(shù),返回他們的和   
(int x, int y) -> x + y   
// 5. 接受一個 string 對象,并在控制臺打印,不返回任何值(看起來像是返回void)   
(String s) -> System.out.print(s) 
定義6個接口，后面我們都會基于這6個接口來演示案例 
/**多參數(shù)無返回*/ 

@FunctionalInterface 
public interface NoReturnMultiParam { 
    void method(int a, int b); 
} 
/**無參無返回值*/ 
@FunctionalInterface 
public interface NoReturnNoParam { 
    void method(); 
} 
/**一個參數(shù)無返回*/ 
@FunctionalInterface 
public interface NoReturnOneParam { 
    void method(int a); 
} 
/**多個參數(shù)有返回值*/ 
@FunctionalInterface 
public interface ReturnMultiParam { 
    int method(int a, int b); 
} 
/** 無參有返回*/ 
@FunctionalInterface 
public interface ReturnNoParam { 
    int method(); 
} 
/**一個參數(shù)有返回值*/ 
@FunctionalInterface 
public interface ReturnOneParam { 
    int method(int a); 
} 
案例代碼： 
public class Test2 { 
    public static void main(String[] args) { 
        //1.簡化參數(shù)類型，可以不寫參數(shù)類型，但是必須所有參數(shù)都不寫 
        NoReturnMultiParam lamdba1 = (a, b) -> { 
            System.out.println("簡化參數(shù)類型"); 
        }; 
        lamdba1.method(1, 2); 
        //2.簡化參數(shù)小括號，如果只有一個參數(shù)則可以省略參數(shù)小括號 
        NoReturnOneParam lambda2 = a -> { 
            System.out.println("簡化參數(shù)小括號"); 
        }; 
        lambda2.method(1); 
        //3.簡化方法體大括號，如果方法條只有一條語句，則可以省略方法體大括號，類似if或for 
        NoReturnNoParam lambda3 = () -> System.out.println("簡化方法體大括號"); 
        lambda3.method(); 
        //4.如果方法體只有一條語句，并且是 return 語句，則可以省略方法體大括號 
        ReturnOneParam lambda4 = a -> a+3; 
        System.out.println(lambda4.method(5)); 
        ReturnMultiParam lambda5 = (a, b) -> a+b; 
        System.out.println(lambda5.method(1, 1)); 
    } 
} 

6、使用lambda 表達(dá)式去引用方法

①引用方法的語法為：方法歸屬者::方法名

注意：靜態(tài)方法的歸屬者為類名，普通方法歸屬者為對象。該代碼案例結(jié)合最上面的自定義函數(shù)式接口：

public class Exe1 { 
    public static void main(String[] args) { 
        ReturnOneParam lambda1 = a -> doubleNum(a); 
        System.out.println(lambda1.method(3)); 
        //lambda2 引用了已經(jīng)實(shí)現(xiàn)的 doubleNum 方法 
        ReturnOneParam lambda2 = Exe1::doubleNum; 
        System.out.println(lambda2.method(3)); 
        Exe1 exe = new Exe1(); 
        //lambda4 引用了已經(jīng)實(shí)現(xiàn)的 addTwo 方法 
        ReturnOneParam lambda4 = exe::addTwo; 
        System.out.println(lambda4.method(2)); 
    } 
    /** 
     * 要求 
     * 1.參數(shù)數(shù)量和類型要與接口中定義的一致 
     * 2.返回值類型要與接口中定義的一致 
     */ 
    public static int doubleNum(int a) { 
        return a * 2; 
    } 
    public int addTwo(int a) { 
        return a + 2; 
    } 
} 

②構(gòu)造方法的引用

一般我們需要聲明接口，該接口作為對象的生成器，通過 類名::new 的方式來實(shí)例化對象，然后調(diào)用方法返回對象。

interface ItemCreatorBlankConstruct { 
    Item getItem(); 
} 
interface ItemCreatorParamContruct { 
    Item getItem(int id, String name, double price); 
} 
public class Exe2 { 
    public static void main(String[] args) { 
        ItemCreatorBlankConstruct creator = () -> new Item(); 
        Item item = creator.getItem(); 
        ItemCreatorBlankConstruct creator2 = Item::new; 
        Item item2 = creator2.getItem(); 
        ItemCreatorParamContruct creator3 = Item::new; 
        Item item3 = creator3.getItem(119, "電腦", 5888.88); 
    } 
} 

使用匿名類與 Lambda 表達(dá)式的一大區(qū)別在于關(guān)鍵詞的使用。

對于匿名類，關(guān)鍵詞 this 解讀為匿名類，而對于 Lambda 表達(dá)式，關(guān)鍵詞 this 解讀為寫就 Lambda 的外部類

7、Lambda再次總結(jié)

• 無參、無返回值的函數(shù)類型(Unit 返回類型不可省略)：() -> Unit;
• 接收T類型參數(shù)、無返回值的函數(shù)類型：(T) -> Unit;
• 接收T類型和A類型參數(shù)、無返回值的函數(shù)類型(多個參數(shù)同理)：(T,A) -> Unit;
• 接收T類型參數(shù)，并且返回R類型值的函數(shù)類型：(T) -> R;
• 接收T類型和A類型參數(shù)、并且返回R類型值的函數(shù)類型(多個參數(shù)同理)：(T,A) -> R;
• 在大括號{}的方法實(shí)現(xiàn)里,如果只有一個參數(shù),可以用it指定而不需要再寫x->...這種代碼;
• 如果方法實(shí)現(xiàn)里有多個參數(shù),則需要x:Int,y:Int->...這種方式指明->后面的自定義參數(shù)名;

總結(jié)

1、Lambda和高階函數(shù)理解起來有點(diǎn)繞，需要大量的練習(xí)和實(shí)驗(yàn)才能慢慢的理解

2、Lambda很深，我們一起來學(xué)習(xí)進(jìn)步