精华内容
下载资源
问答
  • Kotlin 高阶函数

    2020-03-04 16:00:02
    Kotlin高阶函数

    Kotlin高阶函数

    函数类型

    函数类型(Function Type)指就是函数的类型。

    fun add(a: Int, b: Int): Float {
        return (a + b).toFloat()
    }
    
    //函数类型为:
    (Int, Int) -> Float
    

    将函数的参数类型和返回值类型抽象出来后,就得到函数类型。(Int, Int) -> Float表示:参数类型是两个Int返回值类型为Float的函数类型。

    Lambda

    Java中的Lambda

    //Java 普通方法
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Toast.makeText(mContext, "hello", Toast.LENGTH_SHORT).show();
        }
    });
    
    //Java Lambda
    btn.setOnClickListener(v -> Toast.makeText(mContext, "hello", Toast.LENGTH_SHORT).show());
    

    Kotlin中的Lambda

    定义

    {参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}
    
    返回值为函数体的最后一行代码
    
    //Kotlin 普通方法
    btn.setOnClickListener(object : View.OnClickListener {
        override fun onClick(v: View?) {
            Toast.makeText(mContext, "hello", Toast.LENGTH_SHORT).show()
        }
    })
    
    
    //Kotlin Lambda
    btn.setOnClickListener({ v: View ->
                            Toast.makeText(mContext, "hello", Toast.LENGTH_SHORT).show()
                           })
    
    //拖尾lambda表达式
    //如果Lambda是函数的最后一个参数,可以将Lambda写在括号外
    btn.setOnClickListener() { v: View ->
                              Toast.makeText(this, "1aaa", Toast.LENGTH_SHORT).show()
                             }
    
    //还可以省略小括号
    btn.setOnClickListener { v ->
                            Toast.makeText(mContext, "hello", Toast.LENGTH_SHORT).show()
                           }
    
    //如果Lambda是单参,可以省略参数
    btn.setOnClickListener {
        Toast.makeText(mContext, "hello", Toast.LENGTH_SHORT).show()
    }
    

    无参数

    fun say() {
        println("sayHello")
    }
    
    //简化为
    val say = { println("sayHello") }
    

    有参数

    fun sum(a: Int, b: Int): Int {
        return a + b
    }
    
    //等价于
    val sum: (Int, Int) -> Int = { a, b -> a + b }
    
    //等价于
    val sum = { a: Int, b: Int -> a + b }
    

    lambda表达式可以用调用:

    lambda.invoke()
    

    匿名函数

    fun sum(a: Int, b: Int): Int {
        return a + b
    }
    
    //等价于
    val sum = fun(a: Int, b: Int): Int {
        return a + b
    }
    

    带接收者的函数类型

    格式:A.(B, C) -> D

    函数类型加T.的语法结构,表示这个函数类型定义在哪个类中,我们在调用lambda的时候会自动拥有T的上下文,和apply函数的实现方式一样。

    val stringPlus: (a: String, b: String) -> String = { a, b -> a + b }
    val intPlus: Int.(Int) -> Int = { b -> this + b }
    
    println(stringPlus.invoke("<-", "->"))
    println(stringPlus("Hello, ", "world!"))
    
    println(intPlus.invoke(1, 1))
    println(intPlus(1, 2))
    println(2.intPlus(3)) // 类扩展调用
    
    <-->
    Hello, world!
    2
    3
    5
    

    闭包

    一个函数内部申明或返回一个函数,那么这个函数称为闭包。

    在Kotlin中,变量的作用域只有两种:全局变量和局部变量。

    • 全局变量:函数内部和函数外部都可以直接访问。
    • 局部变量:只有在函数内部可以方位。

    闭包的设计就是为了能让开发者在函数外部访问函数内部的局部变量。

    fun main() {
        val t = test() //1
        t()//2
        t()//3
    }
    
    fun test(): () -> Int {
        var a = 1
        println(a)
        return fun(): Int {
            a++
            println(a)
            return a
        }
    }
    

    Kotlin实现接口回调

    Java思想实现

    fun main() {
        val testCallback = TestCallback()
        testCallback.setCallback(object : ICallback {
            override fun onSuccess(msg: String) {
                println("success $msg")
            }
    
            override fun onFail(msg: String) {
                println("onFail $msg")
            }
        })
        testCallback.init()
    }
    
    interface ICallback {
        fun onSuccess(msg: String)
        fun onFail(msg: String)
    }
    
    class TestCallback {
        var myCallback: ICallback? = null
    
        fun setCallback(callback: ICallback) {
            myCallback = callback
        }
    
        fun init() {
            myCallback?.onSuccess("yes")
        }
    }
    

    高阶函数思想实现

    去掉了接口和匿名内部类

    fun main() {
        val testCallback = TestCallback()
        testCallback.setCallback({ println("success $it") }, { println("fail $it") })
        testCallback.init()
    }
    
    class TestCallback {
        var successCallback: (String) -> Unit? = {}
        var failCallback: (String) -> Unit? = {}
    
        fun setCallback(successCallback: (String) -> Unit, failCallback: (String) -> Unit) {
            this.successCallback = successCallback
            this.failCallback = failCallback
        }
    
        fun init() {
            successCallback("yes")
            //failCallback("no")
        }
    }
    
    展开全文
  • Kotlin 高阶函数概念 II . Kotlin 高阶函数 作为 参数 示例解析 ( forEach 方法参数解析 ) III . 用作函数参数的 函数类型变量 ( 本示例中使用匿名函数 ) IV . 函数类型实例使用 V . Kotlin 高阶函数 整体代码示例



    I . Kotlin 高阶函数概念



    Kotlin 高阶函数 : Kotlin 的高阶函数 , 就是方法的参数 或 返回值 是函数类型的 函数 ;


    如 : List 集合的 forEach( ) 循环 , 该方法就是接收一个高阶函数类型变量作为参数 , 有点类似于 C/C++ 中的 函数指针 ( 指向函数的指针 ) ;



    II . Kotlin 高阶函数 作为 参数 示例解析 ( forEach 方法参数解析 )



    1 . 高阶函数引入 : List 集合的 forEach 方法的参数 , 就是一个高阶函数 ;


    2 . forEach () 函数原型 : forEach() 遍历集合的方法需要传入一个参数 , 下面解析这个参数 :

    /**
     * Performs the given [action] on each element.
     */
    @kotlin.internal.HidesMembers
    public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
        for (element in this) action(element)
    }
    

    3 . 参数类型分析 : 由上面的函数原型可以看到 , forEach ( ) 方法的参数是 action: (T) -> Unit , 参数类型是 (T) -> Unit 类型 , 参数变量名称是 action ; 这个参数类型 (T) -> Unit 类型 就是高阶函数类型 ;


    4 . forEach(action: (T) -> Unit) 参数解析 :


    ① 参数名 : action ;

    ② 参数类型 : (T) -> Unit ;

    ③ T 类型 : T 表示 forEach 遍历的集合元素类型 , 这里是 String 类型 ;


    5 . (String) -> Unit 函数类型解析 :


    ① 本质 : 是函数类型 ;

    ② 函数参数 : 其函数类型的参数是 String 字符串类型

    ③ 函数返回值 : 其函数类型的返回值类型是 Unit 类型 , 这是空返回值 相当于 Java 中的 void 类型 ;



    III . 用作函数参数的 函数类型变量 ( 本示例中使用匿名函数 )



    1 . 函数变量需求 : 在上面的 forEach ( ) 函数中 , 需要传入一个 (String) -> Unit 函数类型的变量 , 该函数类型的函数 参数是 String 类型 , 返回值是 Unit 空类型 ;


    2 . 普通的函数声明 : 下面定义的函数 , 参数类型是 String , 返回值是 Unit 空类型 , 这个函数是 (String) -> Unit 类型的 , 但是 study 不能当做参数传入到 forEach 方法中 ; list.forEach(study) , 是错误的调用 , 编译不通过 ;

    fun study(student : String) : Unit{
        println(student + " 在学习")
    }
    

    3 . 函数类型变量 : 可以使用匿名函数 , 赋值给一个变量 , 然后将这个变量当做参数传递给 forEach 当做参数 ;


    ① 指定变量 : 为 (String) -> Unit 类型函数指定一个引用变量 var study2 ;

    ② 匿名函数 : 顾名思义 , 就是没有函数名称 , 省略调上面普通函数的名称 , 赋值给变量 ; 具体用法如下 :

    var study2 = fun (student : String) : Unit{
        println(student + " 在学习")
    }
    


    IV . 函数类型实例使用



    1 . 函数类型实例使用 : 上面的 study2 就是 (String) -> Unit 函数类型的实例变量 ;

    //1 . 定义函数类型实例
    var study2 = fun (student : String) : Unit{
        println(student + " 在学习")
    }
    
    //2 . 使用函数类型实例
    
    //2.1 定义一个集合
    var students : List<String> = listOf<String>("Tom", "Jerry")
    //2.2 遍历集合
    students.forEach(study2);
    

    2 . 执行结果 :

    Tom 在学习
    Jerry 在学习
    


    V . Kotlin 高阶函数 整体代码示例



    Kotlin 高阶函数 整体代码示例 :

    package fp
    
    /*
        这里定义了一个函数 , 参数类型是 String , 返回值是 Unit 空类型
        这个函数是 (String) -> Unit 类型的
        但是不能直接将 study 传入到 forEach 方法中 , 当做参数
     */
    fun study(student : String) : Unit{
        println(student + " 在学习")
    }
    
    /*
        为 (String) -> Unit 类型函数指定一个引用变量 study2
            这个变量值 , 可以直接传递给 forEach 方法当做参数使用
    
        函数名省略 : 将一个函数赋值给一个变量 , 此时函数不能有名称 , 必须是匿名的 ;
    
        该函数可以直接通过 study2("111") 方式调用
     */
    var study2 = fun (student : String) : Unit{
        println(student + " 在学习")
    }
    
    
    fun main() {
    
        //定义一个集合
        var students : List<String> = listOf<String>("Tom", "Jerry")
    
        /*
            forEach 方法 , 接收一个函数作为参数 , 该函数的类型是指定的 , 是 (T) -> Unit 类型
                执行时 , 将集合中的元素传入 (T) -> Unit 类型函数作为参数 , 执行 (T) -> Unit 类型函数内容
    
    
            forEach 函数原型 : forEach() 遍历集合的方法需要传入一个参数 , 下面解析这个参数
                forEach(action: (T) -> Unit) 参数解析 :
                参数名 : action
                参数类型 : (T) -> Unit
                    T 表示 forEach 遍历的集合元素类型 , 这里是 String 类型
                    (String) -> Unit :
                        本质 : 是函数类型
                        函数参数 : 其函数类型的参数是 String 字符串类型
                        函数返回值 : 其函数类型的返回值类型是 Unit 类型 , 这是空返回值 相当于 Java 中的 void 类型
    
    
            Performs the given [action] on each element.
    
            @kotlin.internal.HidesMembers
            public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
                for (element in this) action(element)
            }
         */
        students.forEach(study2);
    }
    

    执行结果 :

    Tom 在学习
    Jerry 在学习
    
    展开全文
  • 温馨提示写博客是为了记录在开发过程中所涉及到的技术...一、基本概念传入或者返回函数的函数函数引用 ::println带有 Receiver 的引用 pdfPrinter::println二、常见高阶函数(forEach/map/flatMap)forEach : 迭代/...

    温馨提示

    写博客是为了记录在开发过程中所涉及到的技术以及遇到的问题的解决,如果该博客对您有所帮助,希望可以点个关注/喜欢;如果您对文章中的内容有什么不同的见解,欢迎留言进行讨论。谢谢!

    一、基本概念

    传入或者返回函数的函数

    函数引用 ::println

    带有 Receiver 的引用 pdfPrinter::println

    二、常见高阶函数(forEach/map/flatMap)

    forEach : 迭代/遍历数组/list

    //forEach函数使用的一般结构

    object.forEach{

    //todo

    }

    例:

    val list = listOf(1,3,5,10,18,36,2,9)

    list.forEach(::println)

    map : 接受一个lambda表达式,并且有返回值,形成一个新的list

    //map函数使用的一般结构

    object.map{

    //todo

    }

    例:

    val newList = list.map{

    it * 2 + 3//相当于返回值

    }

    val newList2 = list.map(Int::toDouble)

    flatMap : 集合数据进行合并成一个集合

    //map函数使用的一般结构

    object.flatMap {

    it

    //todo

    }

    object.flatMap {

    it.map {

    //todo

    }

    }

    例:

    val list = listOf(

    1..20,

    2..15,

    100..166)

    val flatList = list.flatMap{

    it

    }

    val flatList = list.flatMap{

    it.map{

    "No.$it"

    }

    }

    reduce : 使用reduce对集合进行计算操作

    //reduce函数使用的一般结构

    object.reduce{acc,i ->

    //acc 为累计的结果

    //acc todo

    }

    例:

    list.reduce{acc,i -> acc + i}

    fun factorial(n: Int):Int{

    if(n==0) return 1

    return (1..n)reduce{acc,i -> acc * i}

    }

    //对0-6的数分别求阶乘,并且打印出来

    (0..6).map(::factorial).forEach(::println)

    fold : 使用fold对集合进行自定义计算

    //fold函数使用的一般结构

    object.fold([初始值]){acc,i ->

    //todo

    }

    例:

    // 对0-6 的阶乘进行求和并加上初始值 5

    println((0..6).map(::factorial).fold(5){acc,i ->

    acc + i

    })

    //字符串拼接

    println((0..6).map(::factorial).fold(StringBuilder()){acc,i ->

    acc.append(i).append(",")

    })

    // 字符串连接

    println((0..6).joinToString(","))

    foldRight : 与fold不同的是顺序相反

    //foldRight函数使用的一般结构

    object.foldRight([初始值]){i,acc ->

    //todo

    }

    例:

    //字符串拼接

    println((0..6).map(::factorial).foldRight(StringBuilder()){i,acc ->

    acc.append(i).append(",")

    })

    filter : 传入Lambda 表达式为true是,保留该元素;使用filter对集合进行按条件过滤

    //filter函数使用的一般结构

    object.filter{

    //todo

    }

    例:

    //给一个长度为 n 的数组,每个元素都在 [1,n] 之间,要求找出 [1,n] 中没有在数组里出现的元素。

    fun findDisappearNumbers(nums: IntArray): List {

    val ifAppear = BooleanArray(nums.size + 1)

    nums.forEach { ifAppear[it] = true }

    return ifAppear.mapIndexed {

    index, boolean ->

    if (boolean || index == 0) -1 else index

    }.filter { it != -1 }

    }

    takeWhile : 循环遍历集合,直到第一个不满足条件的数据时,停止循环

    //takeWhile函数使用的一般结构

    object.takeWhile{

    //todo

    }

    let : let扩展函数的实际上是一个作用域函数,当你需要去定义一个变量在一个特定的作用域范围内,let函数的是一个不错的选择;let函数另一个作用就是可以避免写一些判断null的操作。

    //let函数使用的一般结构

    object.let{

    it.todo()//在函数体内使用it替代object对象去访问其公有的属性和方法

    ...

    }

    //另一种用途 判断object为null的操作

    object?.let{//表示object不为null的条件下,才会去执行let函数体

    it.todo()

    }

    例:

    data class Person(val name: String,val age:Int){

    fun work(){

    println("$name is working!!!")

    }

    }

    fun findPerson():Person?{

    return null

    }

    fun main(args: Array){

    findPerson()?.let{person ->

    person.work()

    println(person.age)

    }

    }

    apply : apply一般用于一个对象实例初始化的时候,需要对对象中的属性进行赋值;一般可用于多个扩展函数链式调用 ;数据model多层级包裹判空处理的问题

    //apply函数使用的一般结构

    object.apply{

    //todo

    }

    //例:

    //1、

    data class Person(val name: String,val age:Int){

    fun work(){

    println("$name is working!!!")

    }

    }

    fun findPerson():Person?{

    return null

    }

    fun main(args: Array){

    findPerson()?.apply{

    work()

    println(age)

    }

    }

    //2、

    mSectionMetaData?.apply{

    //mSectionMetaData不为空的时候操作mSectionMetaData

    }?.questionnaire?.apply{

    //questionnaire不为空的时候操作questionnaire

    }?.section?.apply{

    //section不为空的时候操作section

    }?.sectionArticle?.apply{

    //sectionArticle不为空的时候操作sectionArticle

    }

    with : 适用于调用同一个类的多个方法时,可以省去类名重复,直接调用类的方法即可

    //with函数使用的一般结构

    with(object){

    //todo

    }

    例:

    val br = Buffered

    run : run函数是let,with两个函数结合体,准确来说它弥补了let函数在函数体内必须使用it参数替代对象,在run函数中可以像with函数一样可以省略,直接访问实例的公有属性和方法,另一方面它弥补了with函数传入对象判空问题,在run函数中可以像let函数一样做判空处理

    //run函数使用的一般结构

    object.run{

    //todo

    }

    also : 适用于let函数的任何场景,also函数和let很像,只是唯一的不同点就是let函数最后的返回值是最后一行的返回值而also函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用

    //also函数使用的一般结构

    object.also{

    //todo

    }

    use : use函数作用于现实了Closeable接口的类,比如文件io操作

    //use函数使用的一般结构

    object.use{

    //todo

    }

    例:

    var l = BufferedReader(FileReader("123.txt")).use {

    var line: String = ""

    while (true){

    line += it.readLine()?: break

    }

    line

    }

    println(l)

    三、尾递归优化

    递归的一种特殊形式

    调用自身后无其他操作

    tailrec 关键字提示编译器尾递归优化

    尾递归与迭代的关系,尾递归一般情况下可以直接转换为迭代

    四、闭包

    闭包就是函数的运行环境

    持有函数运行状态

    函数内部可以定义函数

    函数内部也可以定义类

    五、函数复合

    函数复合就是f(g(x))的形式的函数

    六、Currying (科理化)

    就是多元函数变成一元函数调用链

    fun log(tag:String,target:OutputStream,message:Any?){

    target.write("[$tag]: $message\n".toByteArray())

    }

    fun curriedLog(tag:String):(target:OutputStream) -> (message:Any?){

    //todo

    }

    //fun log(tag:String)

    // =fun (target:OutputStream)

    // =(message:Any?)

    // =target.write("[$tag]: $message\n".toByteArray())

    fun Function3.curried()

    =fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)

    fun main(args: Array){

    log("Test",System.out,"Hello World!")

    // log("Test")(System.out)("Hello World Currying")

    ::log.curried()("Test")(System.out)("Hello World Currying")

    }

    七、偏函数

    传入部分参数之后得到的新函数就是偏函数

    fun log(tag:String,target:OutputStream,message:Any?){

    target.write("[$tag]: $message\n".toByteArray())

    }

    fun Function3.curried()

    =fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)

    fun main(args: Array){

    val consoleLog = (::log.cueried())("Test out")(System.out)

    consoleLog("Hello 偏函数!")

    }

    展开全文
  • Kotlin高阶函数

    2020-11-23 23:32:09
    高阶函数:如果一个函数接收另一个函数作为参数,或者返回值的类型是另一个函数,那么这个函数就成为高阶函数。 写习惯了Java的人可能就在想,编程语言中的参数有整型、字符串类型,布尔型等字段类型, 怎么能接收...
    • 高阶函数:如果一个函数接收另一个函数作为参数,或者返回值的类型是另一个函数,那么这个函数就成为高阶函数。

    写习惯了Java的人可能就在想,编程语言中的参数有整型、字符串类型,布尔型等字段类型,
    怎么能接收一个函数作为参数呢?其实Kotlin新增了一个函数类型的概念,基本定义规则如下:

    (String, Int) -> Unit
    

    看起来有点抽象,一点点解释的话就是 ->左边括号里的,就是该函数类型要接收的参数类型,可以定义好多个,以逗号隔开;->右边用于声明该函数的返回值是什么类型,如果没有返回值就写Unit,它大致相当于Java中的void。那么现在将它当做参数传入函数中:

    fun test(function: (String, Int) -> Unit) {
            function("123", 123)
        }
    

    现在因为test函数接收一个函数作为参数,那么我们就说test函数是一个高阶函数,高阶函数有什么作用呢,这么说吧,以前我们定义的函数,是用来解决某一个问题的,那现在有了高阶函数,就可以根据传入的这个函数来解决很多个问题了,我举个例子,我们做一个两数之和的函数,如果按普通方法写的话,就是这样:
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201123214726679.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E2NDQzODgyNjI=,size_16,color_FFFF
    没毛病老铁,算出两数之和了,但是现在calculate只能做加法,我想做两数之差怎么办呢?那就只能再写个方法去相减了,但是现在有了高阶函数,我们可以这么写:
    在这里插入图片描述
    我把calculate方法改造成了一个高阶函数,除了接收两个Int型的参数之外,最后一个参数接收一个函数,并且这个函数类型的参数的返回值也是Int,在calculate方法中,我们没有做任何事情,只是把参数传给了函数类型的参数,并返回它的返回值。

    由于calculate函数接收一个函数类型的参数,所以我们要先定义好相匹配的参数,也就是接收两个Int型参数并且返回值是Int的函数,于是我定义了一个plus函数和一个minus函数,一个用来相加一个用来相减,你看一眼就明白了。

    calculate函数的第三个参数我用了::plus和::minus这样的写法,这是一种函数引用方式的写法,表示将plus()和minus()函数作为参数传递给calculate()函数,而由于calculate()函数中使用了传入的函数类型参数来决定具体的运算逻辑,因此这里实际上就是分别使用了plus()和minus()函数来对两个数字进行运算。

    但是这样每次都得事先定义好相匹配的函数有点太难搞了,其实我们还可以用 Lanbda表达式来做:
    在这里插入图片描述
    可以看到,效果是一毛一样的。

    我在之前的博客里写apply函数的时候,这么写过:

    val builder = AlertDialog.Builder(this).apply {
        setTitle("我是测试title")
        setMessage("我是测试message")
        setNegativeButton("取消", null)
        setPositiveButton("确定", null)
    }
    builder.show()
    

    创建一个AlertDialog,现在学了高阶函数之后,我们自己手动实现一个apply标准函数,首先新建一个Kotlin file叫MyAlertDialog:
    在这里插入图片描述
    这里我给AlertDialog.Builder类定义了一个myApply扩展函数,这个扩展函数,这个扩展函数接收一个函数类型参数,并且返回值类型也是AlertDialog.Builder。

    注意,这个函数类型参数的声明方式和刚才看到的有所不同:它在函数类型的前面加上了一个AlertDialog.的语法结构。其实这才是定义高阶函数完整的语法规则,在函数类型的前面加上ClassName.就表示这个函数类型是定义在哪个类当中的。

    那在这里将其定义为AlertDialog.Builder类当中有什么好处呢?好处就是当我们调用build函数时将闯入的Lambda表达式将会自动拥有AlertDialog.Builder的上下文,同时这也是apply函数的实现方式,现在我们可以用自己创建的myApply函数来实现这个AlertDialog了:

    val builder = AlertDialog.Builder(this).myApply {
        setTitle("我是测试title")
        setMessage("我是测试message")
        setNegativeButton("取消", null)
        setPositiveButton("确定", null)
    } 
    builder.show()
    

    可以看到,myApply函数和apply函数的用法是一毛一样的,只不过这个myApply函数只能作用在AlertDialog.Builder类上面,如果想完全实现apply的功能,需要用到泛型,那我们就按照完全版的高级函数定义公式,定义出我们自己的完整版的myApply函数:

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

    首先我们想将myApply函数扩展到哪个类上面呢?我们不知道,那就用泛型代替,那泛型哪里来的呢,所以这里用的是泛型方法< T >,然后将myApply函数扩展到T类上,就是T.myApply,之后的T.()就是上面说的ClassName.就表示这个函数类型是定义在哪个类当中的。最后我们将T返回,这样的话,我们的myApply函数,就和Kotlin中的apply函数一毛一样了!!

    展开全文
  • kotlin 高阶函数

    2020-10-04 11:21:10
    seid=9452703838133087376 郭神讲高阶函数 ...高阶函数就是以另一个函数作为参数或返回值的函数,Kotlin可以以lambda或参数引用作为参数或返回值...
  • 主要介绍了详解Kotlin 高阶函数 与 Lambda 表达式的相关资料,需要的朋友可以参考下
  • 主要给大家介绍了关于拥抱kotlin之如何习惯使用kotlin高阶函数的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用kotlin具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,232
精华内容 1,692
关键字:

kotlin高阶函数