高阶函数与lambda表达式

高阶函数与lambda表达式

Lambda表达式格式要求:

• 一个lambda表达式总是被一对花括号所包围。
• 其参数（如果有的话）位于->之前（参数类型是可以省略的）
• 执行体位于 —>之后

val multiply: (Int, Int) -> Int = { a, b -> a * b } //multiply变量接收2个Int参数，并返回一个Int参数，在{}中执行方法体
val substract = { a: Int, b: Int -> a - b }//substract变量没有指定参数，但是在{}中指定参数为Int并返回Int值
val myAction = { println("hello world") }
val mayReturnNull: (Int, Int) -> Int? = { _, _ -> null }
val functionMaybeNull: ((Int, Int) -> Int)? = null
//前2种在实际开发中常用的。

在kotlin中，如果一个函数的最后一个参数是个函数，那么可以将lambda表达式作为实参传递进去，并且可以在调用时方法圆括号外去使用。如下：

fun myCalculate(a: Int, b: Int, calcute: (Int, Int) -> Int): Int {
    return calcute(a, b)
}

fun main(args: Array<String>) {
    println(myCalculate(3, 4, { x, y -> x + y }))//7
    //等价于
    println(myCalculate(3, 4) { x, y -> x + y })
}

高阶函数:

扩展函数使用

fun String.filter(predicate: (Char) -> Boolean): String {
    val sb = StringBuilder()
    for (index in 0 until length) {
        val element = get(index)
        if (predicate(element)) {
            sb.append(element)
        }
    }
    return sb.toString()
}

fun main(args: Array<String>) {
    val str = "hellp24world90"
    println(str.filter { it.isLetter() }) //当一个参数的时候可以使用it
}

高阶函数关键字的使用：

fun main(args: Array<String>) {
    val strings = arrayOf("hello", "world", "helloworld", "welcome")
    strings.filter { it.contains("h") }.forEach { println(it) }
    println("----------------")
    strings.filter { it.length > 6 }.forEach { println(it) }
    println("----------------")
    strings.filter { it.endsWith("d", false) }.map { it.toUpperCase() }.forEach { println(it) }
}
maxBy 返回的是集合     数组.maxBy{  it.age } 返回的是当前数组中最大的年龄对象
filter 筛选  数组.filter  {  it.age>18 and height>169  } 返回的是对象
map 把某个属性映射成一个集合   数组.map {  "&{it.name}: &{it.age}"}返回的是小小：15,按时：46 数组
any  查找数组中是否有满足的条件。 数组.any {  it.age=15 }  返回bolean 类型
count  统计。 数组.count   {  it.age=15 }  返回统计的数字
find   查找 。 数组.find     {  it.age=15 }  返回第一个满足当前条件的对象
groupBy  分组 。数组.groupBy     {  it.age }.get( 15 ).forEach(  print( it )  )  分类返回当前的类别数组

闭包:

fun main(args: Array<String>) {
    var sum = ""
    val strings = arrayOf("hello", "worlds", "bye")
    strings.filter { it.length > 3 }.forEach {
        sum += it
    }
    println(sum) //helloworlds  在高阶函数体内可以使用成员变量
}

解构声明:

使用解构一个方法可以返回2,3个值

data class MyResult(val result: String, val status: Int)

fun myMethod(): Pair<String, Int> {
    return Pair("success", 1)
}

fun myMethod3(): Triple<String, Int, String> {
    return Pair("success", 1, "w3r4")
}

fun myMethod2(): MyResult {
    return MyResult("success", 1)
}

fun main(args: Array<String>) {
    val (result, status) = myMethod2()
    println("$result,$status")
    println("--------------")
    val (result2, status2) = myMethod()  //解构声明可以一个方法返回2个值或是3个值
    println("$result2,$status2")
    println("--------------")
}