高阶函数

高阶函数就是可以将函数作为参数在返回函数的函数

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

fun myFunction(){
    println("1111111")
}

fun main(array: Array<String>) {
    //下面的都是高阶函数的用法
    //传递自定义的函数
    lock(ReentrantLock(), ::myFunction)
    //字面函数（lambda表达式）
    lock(ReentrantLock(),{ println("222222")})
    //函数是最后一个参数()可以省略
    lock(ReentrantLock()){
        println("333333")
    }
}

body有一个函数类型()->T（把它设想为没有参数返回值为T的函数），它引发内部try代码块，并被lock保护，结果通过lock()函数返回

字面函数
字面函数包涵在{}中
参数在->前面声明（参数可以省略）
函数体在->之后声明

kotlin中有一个规定。如果最后一个参数是函数()可以省略

fun <T, R> List<T>.map(transform: (T) -> R):
        List<R> {
    val result = arrayListOf<R>()
    for (item in this)
        result.add(transform(item))
    return result
}

fun main(array: Array<String>) {
    val ints = intArrayOf(1,1,1,1)
    println(ints.map{it -> it*2})
    println(ints.map { it *2 })
}

高阶函数map中使用

字面函数

字面函数或者函数表达式就是一个匿名函数

fun max(strings: ArrayList<String>, body: (a: String, b: String) -> Boolean):String {
    var i:String = ""
    for (it in strings){
        if (body(it,i)){
            i = it
        }
    }
    return i
}

fun main(array: Array<String>) {
    val v = arrayListOf("111","2222","3333")
    println(basic.max(v,{a,b -> a.length >= b.length}))
}

max就是高级函数，其中第二个参数就是字面函数，在max定义的时候使用函数作为参数传入max中，然后在调用max的时候，使用字面函数作为参数传入，上面用例是求出字符串数组中最长的字符串
上面的body就是(a: String, b: String) -> Boolean 他表示函数类型

函数文本文法

val sum1 = {x:Int,y:Int -> x+y}
val sum:(Int, Int) -> Int = {x, y -> x+y }

上面两种写法是等价的，第一种是完整的写法，第二种是简写，如果没有参数，参数可以省略

字面函数和表达式函数的另一个区别是没有本地返回。没有 lable 的返回总是返回到 fun 关键字所声明的地方。这意味着字面函数内的返回会返回到一个闭合函数，而表达式函数会返回到函数表达式自身。

闭包

一个字面函数或者表达式函数可以访问闭包，即访问自身范围外的声明的变量。不像 java 那样在闭包中的变量可以被捕获修改：

函数扩展

val sum = fun Int.(other: Int): Int = this + other