Android进阶之Kotlin高阶函数和Lambda表达式详细讲解

[[415968]]

前言

Lambda语法在Java中已经被广泛的运用，我们在开发Android中几乎上每一个项目也会在项目中接入Lambda插件，因为Lambda确实能简少很多的代码量。

无独有偶，在Kotlin中也是Lambda语法的，在这篇文章中就详细的为大家讲解Lambda语法的编写与使用

一、kotin高阶函数详解

1、高阶函数是将函数用作参数或返回值的函数。这种函数的一个很好的例子是 lock()，它接受一个锁对象和一个函数，获取锁，运行函数并释放锁：

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

body 拥有函数类型：() -> T，所以它应该是一个不带参数并且返回 T 类型值的函数。它在 try{: .keyword }-代码块内部调用、被 lock 保护，其结果由lock()函数返回。如果我们想调用lock()函数，我们可以把另一个函数传给它作为参数(参见函数引用)

2、如果一个函数接收另一个函数作为参数，或者返回值的类型是另一个函数，那么该函数就称为高阶函数

函数类型，基本规则如下：

(String,Int) -> Unit

现在将上述函数类型添加到某个函数的参数声明或者返回值声明上，那么这个函数就是一个高阶函数了，例如

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

func("hello", 123)

}

可以看到这里的 example() 函数接收到了一个函数类型参数，因此 example() 函数就是一个高阶函数;

这里我准备定义一个叫作 num1AndNum2() 的高阶函数，让它接收两个整形和一个函数类型的参数。我们会在 num1AndNum2() 函数中对传入的两个整型参数进行某种运算，并返回运行结果。但具体进行什么运算是由传入的函数类型参数决定的

新建一个名为 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() 函数 
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 的写法，这是一种函数引用方式的写法，表示将 plus() 和 minus() 函数作为参数传递给 num1AndNum2() 函数

如果每次调用任何高阶函数时都还得先定义一个与其函数类型参数相匹配的函数，是不是太复杂了?没错，因此 Kotlin 还支持其他多种方式来调用高阶函数，比如 Lambda 表达式、匿名函数、成员引用等。其中 Lambda 表达式是最常见也是最普遍的高阶函数调用方式，刚才的代码使用 Lambda 表达式来实现(Lambda 表达式最后一行自动作为返回值)，plus() 和 minus() 函数可以删掉了

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、闭包函数

闭包函数 一个函数的返回值是函数，函数的内部包含另一个函数，可以是有参无参的匿名函数

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 
} 
//闭包函数 就是函数作为返回参数 
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中高阶函数案例

map 变换

fun main(args: Array<String>) { 
    val list = listOf(1, 2, 3, 4, 5, 6) 
    val newList = list.map { 
        //对集合中的数据进行操作，然后赋值给新的集合 
        (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 
    //函数作为参数的第二种方式调用 类名::方法名 
    val doubleList2 = list.map(Int::toDouble).forEach(::print) ////1.0 2.0 3.0 4.0 5.0 6.0 
} 

flatMap 对集合的集合进行变换

fun main(args: Array<String>) { 
    val list = arrayOf( 
        1..5, 
        50..55 
    ) 
    //把多个数组集合变成一个数组，并且对数据进行变换 
    val mergeList = list.flatMap { intRange -> //集合内的集合 1..5 , 50..55 
        intRange.map { intElement -> //集合内集合遍历 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() 
    //直接多个数组集合变换成一个结集合 
    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 
    } 
    //筛选 集合中数据 > 2的item 
    val filterList = newList.filter { it > 2 } 
    filterList.forEach(::print) //3453 
    //筛选 集合中下标是奇数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表达式详解

1、Lambda表达式是什么?

• Lambda表达式是JDK8推出一个重要的新特性，虽然看着很高大上，其实Lambda表达式的本质只是一个”语法糖”，习惯了面向对象编程的思想，一开始看起来会有点不习惯这种语法形式，但如果你学过C#，你就会发现语法和C#中的“委托”很像;
• 大家都知道，在Java中万物皆对象，Java 一直都致力维护其对象至上的特征，函数对 Java 而言虽然重要，但在 Java 的世界里，函数无法独立存在，只能依赖于对象来调用。在函数式编程语言中，函数是一等公民，它们可以独立存在，你可以将其赋值给一个变量，或将他们当做参数传给其他函数。JavaScript 就是函数式编程语言最典型的代表;
• 函数式语言提供了一种强大的功能——闭包，相比于传统的编程方法有很多优势，闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。因此Java 现在提供的最接近闭包的概念便是 Lambda 表达式，虽然闭包与 Lambda 表达式之间存在显著差别，但至少 Lambda 表达式是闭包很好的替代者;
• 使用Lambda表达式的目的就是取代大部分的匿名内部类，让我们能写出更简洁优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效;
• 如果在你没有熟练掌握Lambda表达式时，不建议乱用，因为不使用Lambda表达式，你同样可以实现相应功能，只把它当做一种锦上添花的工具就可以了;

2、Lambda表达式语法结构

Lambda表达式基础语法结构如下：

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

其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)，parameters表示参数，expression表示表达式，statements表示代码块。

结构说明如下：

一个 Lambda 表达式可以有零个或多个参数

参数的类型既可以明确声明，也可以根据上下文来推断。

例如：

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

所有参数需包含在圆括号内，参数之间用逗号相隔。

例如：

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

空圆括号代表参数集为空。例如：() -> 42

当只有一个参数，且其类型可推导时，圆括号()可省略。

例如：a -> return a*a

Lambda 表达式的主体可包含零条或多条语句

如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致;

如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中(形成代码块)。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空;

3、Lambda表达式重要特征

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

4、函数式接口详解

①什么是函数式接口

函数式接口在java中是指只有一个抽象方法的接口。

函数式接口，就是适用于函数式编程场景的接口。在java中函数式编程就体现在Lambda，因此函数式接口就是能够适用于lambda使用的接口。只有确保接口中有且仅有一个抽象方法，lambda才能进行顺利的推导;

②语法

@FunctionalInterface注解

注解和@override注解的作用类似。该住处应用于函数式接口的定义上。

一旦使用了该注解来定义函数式接口，编译器就会检查该接口是否是有且仅有一个抽象方法

@FunctionalInterface 
public interface MyFunctionalInterface { 
      void myMethod(); 
} 
将函数式接口作为方法的参数 
public class Demo { 
    private static void dos(FunctionInterface fi){ 
        fi.method(); 
    } 
    public static void main(String[] args) { 
        Demo.dos(()->{System.out.println("lambda表达式");}); 
    } 

5、Lambda表达式基本使用案例

表达式基本使用案例

// 1. 不需要参数,返回值为 5   
() -> 5   
// 2. 接收一个参数(数字类型),返回其2倍的值   
x -> 2 * x   
// 3. 接受2个参数(数字),并返回他们的差值   
(x, y) -> x – y   
// 4. 接收2个int型整数,返回他们的和   
(int x, int y) -> x + y   
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)   
(String s) -> System.out.print(s) 
定义6个接口，后面我们都会基于这6个接口来演示案例 
/**多参数无返回*/ 

@FunctionalInterface 
public interface NoReturnMultiParam { 
    void method(int a, int b); 
} 
/**无参无返回值*/ 
@FunctionalInterface 
public interface NoReturnNoParam { 
    void method(); 
} 
/**一个参数无返回*/ 
@FunctionalInterface 
public interface NoReturnOneParam { 
    void method(int a); 
} 
/**多个参数有返回值*/ 
@FunctionalInterface 
public interface ReturnMultiParam { 
    int method(int a, int b); 
} 
/** 无参有返回*/ 
@FunctionalInterface 
public interface ReturnNoParam { 
    int method(); 
} 
/**一个参数有返回值*/ 
@FunctionalInterface 
public interface ReturnOneParam { 
    int method(int a); 
} 
案例代码： 
public class Test2 { 
    public static void main(String[] args) { 
        //1.简化参数类型，可以不写参数类型，但是必须所有参数都不写 
        NoReturnMultiParam lamdba1 = (a, b) -> { 
            System.out.println("简化参数类型"); 
        }; 
        lamdba1.method(1, 2); 
        //2.简化参数小括号，如果只有一个参数则可以省略参数小括号 
        NoReturnOneParam lambda2 = a -> { 
            System.out.println("简化参数小括号"); 
        }; 
        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 表达式去引用方法

①引用方法的语法为：方法归属者::方法名

注意：静态方法的归属者为类名，普通方法归属者为对象。该代码案例结合最上面的自定义函数式接口：

public class Exe1 { 
    public static void main(String[] args) { 
        ReturnOneParam lambda1 = a -> doubleNum(a); 
        System.out.println(lambda1.method(3)); 
        //lambda2 引用了已经实现的 doubleNum 方法 
        ReturnOneParam lambda2 = Exe1::doubleNum; 
        System.out.println(lambda2.method(3)); 
        Exe1 exe = new Exe1(); 
        //lambda4 引用了已经实现的 addTwo 方法 
        ReturnOneParam lambda4 = exe::addTwo; 
        System.out.println(lambda4.method(2)); 
    } 
    /** 
     * 要求 
     * 1.参数数量和类型要与接口中定义的一致 
     * 2.返回值类型要与接口中定义的一致 
     */ 
    public static int doubleNum(int a) { 
        return a * 2; 
    } 
    public int addTwo(int a) { 
        return a + 2; 
    } 
} 

②构造方法的引用

一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

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 表达式的一大区别在于关键词的使用。

对于匿名类，关键词 this 解读为匿名类，而对于 Lambda 表达式，关键词 this 解读为写就 Lambda 的外部类

7、Lambda再次总结

• 无参、无返回值的函数类型(Unit 返回类型不可省略)：() -> Unit;
• 接收T类型参数、无返回值的函数类型：(T) -> Unit;
• 接收T类型和A类型参数、无返回值的函数类型(多个参数同理)：(T,A) -> Unit;
• 接收T类型参数，并且返回R类型值的函数类型：(T) -> R;
• 接收T类型和A类型参数、并且返回R类型值的函数类型(多个参数同理)：(T,A) -> R;
• 在大括号{}的方法实现里,如果只有一个参数,可以用it指定而不需要再写x->...这种代码;
• 如果方法实现里有多个参数,则需要x:Int,y:Int->...这种方式指明->后面的自定义参数名;

总结

1、Lambda和高阶函数理解起来有点绕，需要大量的练习和实验才能慢慢的理解

 

2、Lambda很深，我们一起来学习进步