Kotlin_lambda表达式_indexoffirst

Kotlin_lambda表达式

在Java8中引入了Lambda表达式，这是最令Java开发者激动和期待的一个功能。那究竟什么是Lambda表达式呢？

Lambda表达式本质上是可以传递给其他函数的一小段代码，我们在之前的Java或者Kotlin中，一个函数的参数可以是一种简单的基本数据类型变量或一个对象实例变量。Lambda表达式的出现可以让我们可以把一段代码当做一个值来进行对待，由于是值，便可以进行传递，所以Lambda可以被当做参数传递给其他函数。Lambda表达式的出现，让我们的代码更加简洁。

1.lambda表达式的优化

fun main(args: Array<String>) {
    //lambda表达式的优化
    val a = 10
    val b = 20
    val r1 = ca3(a,b){a,b->
        a+b
    }
    val r2 = ca3(a,b){a,b->
        a*b
    }
    println("$r1,$r2")
}

fun ca3(a1: Int,a2: Int,bolck:(Int,Int)->Int):Int{
    var res = bolck(a1,a2)
    return res
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

结果
30
200

2.匿名函数

fun main(args: Array<String>) {

    var a = 10
    var b = 20
    var r1 = 0
    //匿名函数为lambda表达式

    r1 = ca1(a,b,{a,b->
        a+b

    })
    println(r1)
    var r2 = ca1(a,b,{a,b->
        a * b

    })
    println(r2)
}
fun ca1(a1: Int,a2: Int,bolck:(Int,Int)->Int):Int{
    var res = bolck(a1,a2)
    return res
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结果
30
200

3.简单的lambda表达式

()以及invoke

fun main(args: Array<String>) {

//    {
//        println("1")
//    }()
    {
        println("2")
    }.invoke()
}
1
2
3
4
5
6
7
8
9

结果
2

4.有参数的lambda表达式

fun main(args: Array<String>) {
//    val res = {a:Int,b:Int->
//        a+b
//    }(10,20)
//    println(res)
    val res1 = {a:Int,b:Int->
        a+b
    }.invoke(10,20)
    println(res1)
}
1
2
3
4
5
6
7
8
9
10

结果
30

5.invoke的特点

可以接纳null

fun main(args: Array<String>) {
//    val block:()->Unit =
//    {
//        println("1")
//    }
//    block()
//    block.invoke()
    val block1:(()->Unit)? = null
    {
        println("1")
    }
    block1?.invoke()
}
1
2
3
4
5
6
7
8
9
10
11
12
13

结果
1

6.lambda表达式_it

当只有一个参数的时候可以用到it。

fun main(args: Array<String>) {

    var a = 10
//    val res = ca4(a, {a ->Int
//      a+10
//    })
//    println(res)
    //当只有一个参数的时候可以用到it
    var res1 = ca4(a,{it
    it+10
    })
    println(res1)
}
fun ca4(a1: Int,bolck:(Int)->Int):Int{
    return bolck(a1)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

结果
20

7.lambda表达式_foreach

fun main(args: Array<String>) {
    var str = "里斯"

    str.forEach ({ char->
        println(char)
    })
    //lambda表达式优化,括号迁移
    str.forEach() {char->
        println(char)
    }
    //当括号中没有参数的时候可以省略
    str.forEach { char->
        println(char)
    }
    //lambda表达式只有一个参数,可以使用it
    str.forEach {
        println(it)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

结果
里
斯
里
斯
里
斯
里
斯
lambda表达式优化的时候为括号迁移,如果括号里没有参数的时候可以省略括号

8.lambda表达式_indexoffirst

判断第一个字符是否为某个字符。然后返回index

fun main(args: Array<String>) {
    val arrayOf = arrayOf("11", "21", "13")
    //判断第一个字符为1开头的索引
    var index = arrayOf.indexOfFirst { it
        it.startsWith("1")
    }
    println(index)
}
1
2
3
4
5
6
7
8

结果
0

9.注意

一般lambda表达式返回的是最后一行

fun main(args: Array<String>) {
    val res = {
        "a"
        println("1")

    }()
    //lambda表达式返回最后一行
    println(res)
}
1
2
3
4
5
6
7
8
9

结果
1