Kotlin - Lambda表达式

Kotlin - Lambda表达式

Kotlin中的Lambda表达式‌是一种简洁的函数定义方式，主要用于简化代码和提高可读性。Lambda表达式在Kotlin中非常强大，可以用于各种场景，包括高阶函数、集合操作、事件监听等。

基本语法和定义
Kotlin中的Lambda表达式用一对大括号{}括起来，参数在->之前声明，函数体在->之后。
如果Lambda表达式没有参数，可以省略括号。例如：
    val lambda = { println("无参数") }
如果Lambda表达式有参数，可以这样定义：
    val lambda = { a: Int, b: Int -> a + b }

使用场景和示例：
1、‌基本使用‌：Lambda表达式可以用于简单的函数定义和调用。例如，定义一个加法函数：
        val sum = { a: Int, b: Int -> a + b }
2、‌作为高阶函数的参数‌：Lambda表达式可以作为高阶函数的参数，例如过滤集合中的元素：
        val numbers = listOf(1, 2, 3, 4, 5)
        val evenNumbers = numbers.filter { it % 2 == 0 } // 结果是 [2, 4]
3、‌集合操作‌：在集合操作中，Lambda表达式用于对每个元素应用操作：
        val numbers = listOf(1, 2, 3, 4, 5)
        val doubled = numbers.map { it * 2 } // 结果是 [2, 4, 6, 8, 10]
4、‌事件监听器‌：在Android开发中，Lambda表达式常用于简化事件监听器的实现：
        button.setOnClickListener { // 处理点击事件 }

例子(testLambda3方法调用)：

class TestLambda2 {

    @Test
    fun test(){
        //testLambda1()
        //testLambda2()
        //testLambda3()
        //testLambda4()
        //testLambda5()
        testLambda6()
    }

    /**
     * 有返回值
     */
    private fun testLambda6(){
        var myFun : (Int) -> String = hasReturn@{
            if(it == 6){
                return@hasReturn "有返回值-内：${it}"
            }
            return@hasReturn "有返回值-外：${it}"
        }
        println( myFun(6))
        println( myFun(8))
    }

    /**
     * 无返回值
     */
    private fun testLambda5(){
        var myFun : (Int) -> Unit = noReturn@{
            if(it == 3){
                println("无返回值 a : ${it}")
                return@noReturn
            }
            println("无返回值 b : ${it}")
        }
        myFun(3)
        myFun(5)
    }

    /**
     * Lambda表达式：尾随Lambda表达式
     * 当一个函数的最后一个参数是函数类型参数时，可以使用尾随Lambda表达式
     */
    private fun testLambda4(){
        outFun {
            println("无参inFun")
        }

        outFun2 {a->
            println("有参inFun a : ${a}")
        }

        outFun3 { a, b ->
            a * b
        }

        outFun4("aaa", {
            println("22外层函数有多个参数 inFun")
        })

        //当外层函数的最后一个参数是函数类型时，可以将 {} 提到 () 外面，该语法称为“尾随 Lambda 表达式”。
        outFun4("abc"){
            println("外层函数有多个参数 inFun")
        }
    }

    /**
     * 外层函数有多个参数：当外层函数的最后一个参数是函数类型
     */
    private fun outFun4(a :String, inFun:() -> Unit){
        inFun()//打印
        println("外层函数有多个参数 outFun, ${a}")
    }

    /**
     * 有参返回值函数
     */
    private fun outFun3(inFun : (Int, Int) -> Int){
        println("有参返回值函数：" + inFun(3, 5))
    }

    /**
     * 无参函数
     */
    private fun outFun2(inFun : (String) -> Unit){
        inFun("abc")
    }

    /**
     * 无参函数
     */
    private fun outFun(inFun : () -> Unit){
        inFun()
    }

    /**
     * Lambda表达式：常规调用
     */
    private fun testLambda3(){
        //第一种
        var myFun:(String) -> Unit = { a->
            println("testLambda3 a : ${a}")
        }

        //只有一个参数，简写
        var myFun3 : (String) -> Unit = {
            println("testLambda3 it : ${it}")
        }

        //第二种
        var myFun2 : (String) -> Unit = fun(b : String) {
            println("testLambda3 b : ${b}")
        }

        //有返回值
        var myFun4 : (Int, Int) -> Int = {a, b ->
            a + b
        }

        //有返回值-另一种写法
        var myFun5 : (Int, Int) -> Int = fun(a : Int, b : Int) : Int {
            return a + b
        }

        myFun("测试1")
        myFun2("测试2")
        myFun3("测试3")
        println("有返回值" + myFun4(3, 4))
        println("有返回值另一种写法：${myFun5(5, 8)}")
    }

    /**
     * 无参Lambda表达式
     */
    private fun testLambda2(){
        var myFun:() -> Unit = {
            println("testLambda2---11()")
        }

        myFun()
    }

    private fun testLambda1(){
        val actionFun = {name :String, age :Int -> "student ${name} ${age} years old , say hello"}
        studentDoSomething("Kotlin", 3, actionFun)
    }

    private fun studentDoSomething(name :String, age : Int, action :(String, Int) -> String){
        val act = action(name, age)
        println(act)
    }
}