Kotlin lambda表达式

Kotlin lambda表达式初步总结如下

ex1:

//只有形参，返回值为空，参数的名称在函数中aStr, bStr运算是->println
val method : (String, String) -> Unit= {aStr, bStr -> println("aStr: $aStr, bStr: $bStr")}
method("Hello", "World")

输出：

I/System.out: aStr: Hello, bStr: World

ex2:

//函数只想执行println
val method02 = { println("This is ")}
method02.invoke() //等价method02()

输出：

This is 

ex3:

//形参只有一个是String,Kotlin会默认这个参数是it
val method03: (String) -> Unit = {
    println("This is : $it")
}
method03("Hello World")

输出

This is : Hello World

ex4:

//Int类型的形参，返回是Void，判断it的数，返回不同的print
val method04: (Int) -> Unit = {
      when (it) {
           1 -> println("结果是1")
           in 10..30 -> println("结果是10~30")
           else -> println("结果没有")
      }
}
method04(1)
method04(20)
method04(40)

输出

结果是1
结果是10~30
结果没有

ex5:

//2个Int类型的形参，不会默认是it,传递实参需要自己写上去
val method05: (Int, Int) -> Unit = { aInt, bInt ->
    println("第一个是：$aInt,第二个是：$bInt")
}
method05(2, 9)

输出

第一个是：2,第二个是：9

ex5:

//虽然2个形参，但是只想接受一个形参，使用下划线占位
val method06: (Int, Int) -> Unit = { aInt, _ ->
    println("第一个是：$aInt")
}
method05(2, 9)

输出

第一个是：2

下面是部分demo

private fun testLambda() {
        //TODO 方式1 仅仅一个函数，此函数没有输入参数，没有返回值，只是打印内容
        val method01 = { println("这是方法1===") }
        method01()
        method01.invoke()
        //输出结果： 这是方法1===
        //         这是方法1===

        //TODO 方式2 仅仅一个函数，此函数没有输入参数，返回值是固定内容的字符串
        val method02 = { "这是方法2===" }
        println(method02())
        //输出结果： 这是方法2===

        //TODO 方式3 函数参数是2个Int，输出参数String
        val method03 = { number1: Int, number2: Int -> number1.toString() + number2.toString() }
        println(method03(99, 55))
        //输出结果： 9955

        //TODO 方式4 (Int, Int) -> Int) 输入参数是2个Int，输出推到出为Int
        val method04 = { number1: Int, number2: Int -> number1 + number2 }
        println(method04(9, 9))
        //输出结果： 18

        //TODO 方式5 函数的申明和函数的实现分开写
        val method05: (Int) -> String //函数的申明
        method05 = fun(value: Int): String = value.toString() + "Kotlin" //函数的实现
        println(method05.invoke(999))
        //输出结果： 999Kotlin

        //TODO 方式6 函数的申明和函数的实现写在一起，返回值是String
        val method06: (Int, Int) -> String =
            fun(number1, number2) = number1.toString() + number2.toString()
        println(method06.invoke(999, 555))
        //输出结果： 999555

        //TODO 方式7 输入类型都是String,返回值是无参，没有返回值
        val method07: (String, String) -> Unit =
            { aStr, bStr -> println("aStr==$aStr, bStr==$bStr") }
        method07.invoke("Hello", "World")
        //输出结果： aStr==Hello, bStr==World

        //TODO 方式8 只有一个参数的时候，默认可以通过it来获取到
        val method8: (String) -> Unit = {
            println("This is Kotlin, and parameter is: $it")
        }
        method8.invoke("mohaha")
        //输出结果： This is Kotlin, and parameter is: mohaha

        //TODO 方式9 默认参数it和when一起使用
        val method09: (Int) -> Unit = {
            when (it) {
                1 -> println("参数是1")
                in 21..50 -> println("参数是21到50之间")
                else -> println("数据是默认的")
            }
        }
        method09(1)
        //输出结果： 参数是1

        //TODO 方式10 多个参数时，如果不想使用某一个参数，可以使用"_"，拒绝接受对应的参数，下面拒绝接受第一个参数
        val method10: (Int, Int) -> Unit = { _, number2 ->
            when (number2) {
                1 -> println("参数是1")
                in 21..50 -> println("参数是21到50之间")
                else -> println("数据是默认的")
            }
        }
        method10(1, 32)
        //输出结果： 参数是21到50之间

        //TODO 方式11 参数是Any 接受类型也是Any,(Any) -> Any,相当于Object
        val method11 = { str: Any -> str }
        println(method11("Kotlin"))
        println(method11(1))
        println(method11(false))
        //输出结果： Kotlin
        //         1
        //          false

        //TODO 方式12 Kotlin if语句
        val method12 =
            { sex: Char ->
                if (sex == '男') println("This is man") else if (sex == '女') println("this is woman") else {
                    println("This is human")
                }
            }
        method12.invoke('o')
        //输出结果： This is human

        //TODO 方式13  为String类型进行扩展，扩展函数，对谁扩展，this就是谁本身，这里是this就是String
        val method13: String.() -> Unit = {
            println("method13被调用， 调用者是$this")
        }

        //扩展函数
        fun <T> T.test() = println("Test被调用，Test是 $this")
        "Kotlin".test()
        123.test()
        true.test()
        //输出结果： Test被调用，Test是 Kotlin
        //         Test被调用，Test是 123
        //         Test被调用，Test是 true
        "My".method13()
        //输出结果： method13被调用， 调用者是My
    }