函数-高阶函数-Lambda

1. 函数调用省略

var method01:(Int)->Unit = {value -> println(value)}
fun main() {
    method01(111)
    method01.invoke(22222)
}

函数调用省略invoke() 直接使用 (......)

2. 函数声明与实现

: (参数)->返回
= {参数->方式}

的步理解声明和实现, 有点C++的身影

    var method02 : (Int)->String // 先声明
    method02 = fun(value : Int) : String= value.toString() // 后实现
    println(method02(99))

    // 用 先声明 的类型，来 自动推断
    var method03 : (Int)->String // 先声明
    method03 = fun(value)  = value.toString() // 后实现
    println(method03(99))

    // 声明 + 实现 一气呵成
    var method04 : (Int) -> String/*左边是声明*/= {value-> "$value aaa"}/*右边是实现*/
    println(method04(77))

3. 函数的几种类型接收和返回参数

fun showAction(action: (Int) -> String) {
    println(action(88))
}

fun lambdaImpl(value: Int) = "my value is$value"


   showAction(::lambdaImpl)
    val r1: Function1<Int,String> = ::lambdaImpl
    val r2: (Int) -> String = ::lambdaImpl
    val r3: Int.() -> String = r2

多个lambda的函数

fun lambdaMulti(lambda1:(String)->Unit,lambda2:(Int)->Unit){
......
}
--------------------------------
    lambdaMulti({},{})
    lambdaMulti({
        
    }){
        
    }

一个Lambda嵌套的有趣例子

val fan: (String) -> (String) -> (Boolean) -> (Int) -> (String) -> Int = {
        {
            {
                {
                    {
                        99
                    }
                }
            }
        }
    }
    println(fan("AAA")("bbb")(false)(44)("aaaa"))

模拟添加事件,lambda 没法用泛型，用any替代

class AndroidClickListener<T> {
    private val actions = arrayListOf<(T?) -> Unit>()
    private val valuse = arrayListOf<T?>()

    fun addListener(value: T?, action: (T?) -> Unit) {
        if (!actions.contains(action)) {
            actions += action
            valuse += value
        }
    }

    fun touchListeners() {
        if (actions.isEmpty()) {
            println("not action")
            return
        }
        actions?.forEachIndexed { index, item ->
            item.invoke(valuse[index])
        }
    }
}

fun <T> show(value: T?) {
    println("event is value：$value")
}

fun main() {
    val func = AndroidClickListener<String>()
    func.touchListeners()
    func.addListener("zcwfeng") {
        println("事件执行 ，value is $it")
    }
    //lambda 没法用泛型，用any替代
    var result: (Any?) -> Unit = ::show
    val method1: (Any) -> Unit = {}
    func.touchListeners()

    println()

    // 我想传递 事件
    func.addListener("zcwfeng", ::show)
    // lambda无法玩泛型
    func.touchListeners()
}

4. 函数定义

fun study01() = {
}

这句话是两个函数

看个复杂点的例子，包含一个lambda函数

fun study01() = { name:String,age:Int->
    true
    name
    age
    "name is:$name,age is: $age"
}

fun study02() = {lambdaAction:(Int,Int)->String,studyInfo:String->
    false
    '男'
    val lambdaAction = lambdaAction(10,10)
    println("lambdaAction function result is :$lambdaAction + $studyInfo")
}


fun main() {
    println(study01()("zcwfeng",99))
    study02()({n1,n2->
        "两个num相加得到的结果：${n1 + n2}"
    },"zcwfeng")
}

------------------------
来看函数的返回类型

fun study03() = { str:String,num:Int,lambda1:(String)->Unit,lambda2:(Int)->Unit ->
    lambda1(str)
    lambda2(num)
}

返回类型 (String,Int,(String)->Unit,(Int)->Unit) -> Unit

study03()("zcwfeng",11,{
        println("lambda1 value is:$it")
    }){
        println("lambda2 value is:$it")
    }

最后一个lambda可以写到（）后面也可以卸载参数里study03()("","",{},{})或者study03()("","",{}){}

泛型化
fun <T1, T2, R1, R2> study04() = { str: T1, num: T2, lambda1: (T1) -> R1, lambda2: (T2) -> R2 ->
    println("lambda1 is value ${lambda1(str)}")
    println("lambda2 is value ${lambda2(num)}")

}

  study04<String, Int, Int, String>()("zcwfeng", 100, {
        "$it".length// 类似rx str to int
    }, {
        "$it to String"// int to string
    })

5. 模仿RXJava 的操作符

fun main() {
    create {
        "zcwfeng"
    }.map {
        it.length
    }.map {
        "长度是$it"
    }.map {
        "[$it]"
    }.compose {
        println(it)
    }
}

//保存map
class Helper<T>(private var item: T) {
    // 链式调用
    fun <R> map(lambda: (T) -> R) = Helper(item)
    fun compose(action: (T) -> Unit) = action(item)
}
fun <R> create(action: () -> R) =  Helper(action())

通过扩展函数简化后的代码

fun main() {
    create {
        "zcwfeng"
    }.map {
        length
    }.map {
        "长度是$this"
    }.map {
        "[$this]"
    }.compose {
        println(this)
    }
}

//保存map
class Helper<T>(var item: T)
// 链式调用
fun <T,R> Helper<T>.map(lambda: T.() -> R) = Helper(lambda(item))
fun<T> Helper<T>.compose(action: T.() -> Unit) = action(item)
fun <R> create(action: () -> R) = Helper(action())

6. forEach 内置函数仿写

使用

    listOf("aaa", "bbb", "ccc")
        .forEach {
            println(it)
        }
    println();
    listOf("aaa", "bbb", "ccc")
        .mForeach {
            println(it)
        }
----------
inline fun <T> Iterable<T>.mForeach(lambda: (T) -> Unit) = kotlin.run {for (item in this) lambda(item) }

如果Lambda中println（this）我不想用it，那么稍微改造下

inline fun <T> Iterable<T>.mForeach(lambda: T.() -> Unit) = kotlin.run {for (item in this) lambda(item) }

不用系统的run，自己实现
inline fun <T> Iterable<T>.mForeach(lambda: T.() -> Unit) = r { for (item in this) lambda(item) }
inline fun <R> r(lambda: () -> R) = lambda()

小技巧：T.() 扩展写法持有this----(T) 持有的是it

7. 仿写let内置函数

 "zcwfeng".let {
        'a'
        0
        99.99
    }
    "zcwfeng".mLet {
        '2'
        111
        println("value is $it")
        false
    }

inline fun <T, R> T.mLet(lambda: (T) -> R): R = lambda(this)

7. 仿写repeat内置函数

 repeat(10){
        println("下标是$it")
    }

 mRepeat(10){
        println("下标是$it")
    }

    10.mRepeat2{
        print("下标是$it ")

    }

private inline fun mRepeat(count:Int,lambda: (Int) -> Unit){
    for (index in 0 until count) lambda(index)
}

private inline fun Int.mRepeat2(lambda: (Int) -> Unit){
    for (index in 0 until this) lambda(index)
}

8. 仿写内置函数repeat

 val test = "zcwfeng".takeIf {
        true
        false
    }
    println(test)
    val test1 = "zcwfeng".mTakeIf {
        true
        false
    }
    println(test1)

private inline fun <T> T.mTakeIf(lambda: (T) -> Boolean): T? = if (lambda(this)) this else null

9 . 仿写内部thread函数

 thread {
        println("thread")
    }
    mThread(/*name = "dddd"*/) {
        println("mThread ${Thread.currentThread().name}")
    }

private inline fun mThread(
    start: Boolean = true,
    name: String? = null,
    crossinline runAction: () -> Unit
) {
    val thread = object : Thread() {
        override fun run() {
            super.run()
            runAction()
        }
    }
    if (start) thread.start()
    name?.let { thread.name = name }
}

crossinline 声明是防止inline的发生，防止代码错误