Kotlin 方法

扩展方法

fun StringBuilder.addLine(value: CharSequence?): StringBuilder = append(value).append(System.lineSeparator())

fun StringBuilder.addLine(value: CharSequence?): StringBuilder {
    return this.append(value).append(System.lineSeparator())
}

方法内扩展有效

fun stringFunction() {
    fun String.someOtherFunction() {
        println(this + " world")
    }
    "hello".someOtherFunction()
}

Lamda方法

var myMethod1: () -> Unit = {
    println("hello kotlin")
}

var myMethod2 = {
    println("hello kotlin")
}
var myMethod3 = fun(x: Int): Int {
    return x * x
}
var myMethod4: (arg: String) -> String = { arg ->
    //to do handle
    "hello $arg"
}
fun main(args: Array<String>) {
    myMethod1()
    myMethod2()
    println(myMethod4("world"))
    
    listOf(1, 2, 4).map { it ->
        mutiNum(it)
    }
    listOf(1, 2, 4).map(mutiNum)
}

最后一个表达式就是 lambda 的结果

val total = { x: Int, y: Int ->
        println("start count")
        x + y
}
println(total(1, 4))

方法作为参数

var doubleUp1 = { va: Int ->
    println("do a thing")
    va * 2
}

fun doubleUp2(va: Int): Int {
    println("do a thing")
    return va * 2
}

fun applyAndPrint(values: Array<Int>, modifier: (value: Int) -> Int) {
    for (i in values)
        println(modifier(i))
}

fun main(args: Array<String>) {
    applyAndPrint(arrayOf(1, 2, 3), doubleUp1)
    //如果方法的最后一个参数是lamda表达式，则可以这样调用
    applyAndPrint(arrayOf(1, 2, 3)) {
        doubleUp2(it)
    }
}
public inline fun measureTimeMillis(block: () -> Unit): Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}

高阶函数

fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
    return if (predicate(this)) this else null
}

inline fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}

class Builder(val multiplier: Int) {

    fun invokeStuff(action: Builder.() -> Unit) {
        this.action()
    }

    fun multiply(value: Int): Int {
        return value * multiplier
    }

    infix fun Int.doStuff(value: Int): Int {
        return value * multiplier
    }

}

fun main(args: Array<String>) {
    val builder = Builder(10)
    builder.invokeStuff {
        val result1 = multiply(1)
        println(result1)
//        val result2 = 1.doStuff(50)
        //中缀调用
        val result2 = 1 doStuff 50
        println(result2)
    }
}

定义中缀调用的方法只有一个参数，需要使用 infix 修饰符来标记

higher-order-functions

looking-at-kotlin---fun-with-functions