深入解析Kotlin(之) lambda表达式和高阶函数操作符

【Kotlin】Kotlin的高阶函数与Lambda表达式 前言 Kotlin的高阶函数与Lambda表达式是Kotlin的特色,使用频率非常高。熟悉它的用法与本质对于简化代码、提升开发效率非常有帮助,也易于阅读kotlin的框架源码。 这两个概念并不是一个东西,但是又有非常紧密的关联。这篇文章带你弄懂什么是高阶函数,以及Lambda表达式的本质和使用。 一、什么是高阶函数 高阶函数就是将函数用作参数或返回值的函数。 函数类型 Kotlin 使用类似 (Int) -> String 的一系列函数类型来处理函数的声明,例如onClick: val onClick 阅读详情

前言

以一个java老鸟的角度,如何去看 kotlin。 Java源代码应该如何用Kotlin重构。 如何正确学习kotlin并且应用到实际开发中。本文将会探究。

本文分两大块,重难点和潜规则。

重难点:Kotlin中可以独立出来讲解的大块知识点。提供单独Demo。这部分大多数是Kotlin开创的新概念(相比于Java)。

潜规则:Kotlin是谷歌用来替换Java的,它和java百分百完全兼容,但是实际上java转成kotlin之后,需要我们手动修改很多东西,甚至某些部分必须打散重构来达到最优编码。其中,kotlin的某些特性和java不同,甚至完全反转。这部分知识点比较零碎,单独Demo不方便提供,就以小例子的形式来写。

正文大纲

  • 重难点

    • lambda以及操作符
    • 高阶函数以及操作符
    • Kotlin泛型
    • 集合操作
    • 协程
    • 操作符重载
  • 潜规则

    • Kotlin文件和类不存在一对一关系

    • 共生体

    • 继承

    • 修饰符

    • 空指针问题

正文

重难点

lambda表达式

lambda表达式是JDK1.8提出的,目的是为了改善Java中大量出现的只有一个方法的回调函数的累赘写法。这里不讨论Java的lambda. Kotlin中lambda已经融入代码核心,而不是像java一样是个注解+语法糖。

基础:

image

一个lambda表达式如图:

lambda 表达式的4个部分

  • 外围的{}大括号
  • 参数列表:x:Int,y:Int
  • 连接符 ->
  • 方法体 x+y
举个栗子

这是一个kotlin文件:

/**
 * 比如说这样,我要给这个doFirst方法传一个执行过程,类型就是一个输入2个Int,输出一个Int的拉姆达表达式
 */
fun calculate(p1: Int, p2: Int, event1: (Int, Int) -> Int, event2: (Int, Int) -> Int) {
    println("执行doFirst")
    println("执行event1 ${event1(p1, p2)}")
    println("执行event2 ${event2(p1, p2)}")
}

//测试lambda表达式
fun main() {
    val sum = { x: Int, y: Int ->
        print("求和 ")
        x + y
    }
    val diff = { x: Int, y: Int ->
        print("求差 ")
        x - y
    }
    //kotlin里面,可以把拉姆达表示当作一个普通变量一样,去传递实参
    calculate(p1 = 1, p2 = 2, event1 = sum, event2 = diff)
}

定义了一个calculate函数, p1,p2 是Int,而event1和event2 则是 lambda表达式. 高级语言特性,一等函数公民:函数本身可以被当作普通参数一样去传递,并且调用。那么, kotlin的lambda内核是怎么样的?

image

上图能够看出,

  1. calculate方法的后面2个参数,被编译成了 Function2 类型。
  2. 执行event1,event2,则是调用其invoke方法
  3. main函数中,出现了null.INSTANCE, 这里比较诡异,INSTANCE应该是用来获取实例的,但是为什么是null.INSTANCE

而看了Function2的源码,简直亮瞎了我的钛合金狗眼:

image

Function.kt文件中:

Function接口,Function2接口.....Function22接口。好了,不要质疑谷歌大佬的设计思路,反正大佬写的就是对的...这里用22个接口(至于为什么是22个,猜想是谷歌觉得不会有哪个脑子秀逗的开发者真的弄22个以上的参数挤在一起吧),表示kotlin开发中可能出现的lambda表达式参数列表。

再举个栗子

给一个Button 设置点击事件,kotlin的写法是:

val btn = Button(this)
val lis = View.OnClickListener { println("111") }
btn.setOnClickListener(lis)

或者:

val btn = Button(this)
btn.setOnClickListener { println("111") }

setOnClickListener 方法的参数是 OnClickListener 接口:

public interface OnClickListener {
    void onClick(View v);
}

类似这种符合lambda表达式特征的接口,都可以使用上述两种写法来大大简化代码量。

最后一个栗子

不得不提一句,lambda表达式有一个变形,那就是:当lambda表达式作为方法的最后一个参数时,可以lambda表达式放到小括号外面。而如果只有一个参数就是lambda表达式,那么括号可以省略

这个非常重要,不了解这个,很多地方都会感觉很蛋疼。

fun testLambda(s: String, block: () -> String) {
    println(s)
    block()
}

fun testLambda2(block: () -> String) {
    block()
}

fun main() {
    testLambda("第一个参数") {
        println("block函数体")
        "返回值"
    }
    testLambda2 {
        println("block函数体")
        "返回值"
    }
}

总结

Kotlin中lambda表达式可以当作普通参数一样去传递,去赋值,去使用。


高阶函数以及操作符

上文提到,kotlin中lambda表达式已经融入了语言核心,而具体的体现就是高阶函数,把lambda表达式当作参数去使用. 这种将lambda表达式作为参数或者返回值的函数,就叫高阶函数。

官方高阶函数

Kotlin谷歌已经给我们封装了一些高阶函数。

  • run
  • with
  • apply
  • also
  • let
  • takeif 和 takeunless
  • repeat
  • lazy
run函数详解

代码如下(这里为了展示代码全貌,忽视androidStudio的代码优化提示):

class A {
    val a = 1
    val b = "b"
}
fun testRun() {
    //run方法有两种用法,一个是不依赖对象,也就是作为全局函数
    run<String> {//我可以规定返回值的类型
        println("我是全局函数")
        "返回值"
    }
    val a = A()
    //另一种则是 依赖对象
    a.run<A,String> {//这里同样可以规定返回值的类型
        println(this.a)
        println(this.b)
        "返回值"
    }
}
fun main() {
    testRun()
}

如上所示:

run函数分为两类

  • 不依赖对象的全局函数。

  • 依赖对象的"类似"扩展函数。

    两者都可以规定返回值类型(精通泛型的话,这里应该不难理解,泛型下一节详解)。

阅读源码:

@kotlin.internal.InlineOnly
public inline fun <R> run(block: () -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

run函数被重载,参数有所不同

  • 前者 参数类型为 ()->R ,返回值为 R ,函数体内执行block(),并且返回执行结果
  • 后者 参数类型为 T.()->R ,返回值为R , T.() 明显是依赖 T类的(貌似T的扩展函数),返回值依然是R,执行完之后返回结果。
  • 并且,可以发现 两者都是内联函数 inline (执行代码时不进行方法的压栈出栈,而是类似于直接在目标处执行代码段)

所以,前者不需要依赖对象,后者必须依赖对象(因为它是T类的"扩展函数")

使用场景

根据run方法的特性,无论是不是依赖对象,它都是封装了一段代码,而且还是inline的。所以:

  • 如果你不想把一段代码独立成方法,又不想让它们看上去这么凌乱,最重要的是告诉后来的开发者 这段代码是一个整体,不要随便给我在里面插代码,或者拆分。那就用run方法,把他们整合到一个作用域中。

    run {
        println("这是一段代码逻辑很相近的代码段")
        println("但是我不想把他独立成一个方法")
        println("又担心别人会随便改")
        println("所以用run方法把他们放在同一个作用域中")
        println("小组中其他人看到这段,就知道不要把无关代码插进来")
    }
    
    
  • 更神奇的是,这个run函数是有返回值的,参数返回值可以利用起来:

    fun testRun2(param1: String, param2: String, param3: String) {
        //我想让这几个参数都不为空,如果检查是空,就不执行方法主体
        val checkRes: Boolean = run<Boolean> {
            when {
                param1.isNullOrEmpty() -> {
                    false
                }
                param2.isNullOrEmpty() -> {
                    false
                }
                param3.isNullOrEmpty() -> {
                    false
                }
                else -> true
            }
        }
    
        if (checkRes){
            println("参数检查完毕,现在可以继续接下来的操作了")
        }else{
            println("参数检查不通过,不执行主体代码")
        }
    }
    fun main() {
      testRun2("1", "2", "")
    }
    
    

main运行结果:

参数检查完毕,现在可以继续接下来的操作了

小结论

run方法在整合小段代码的功效上,还是很实用的

其他高阶函数

上面列举出来的这些系统高阶函数原理上都差不多,只是使用场景有区别,因此除了run之外,其他的不再详解,而只说明使用场景。

apply

和run只有一个区别,run是返回block()执行之后的返回值,而,apply 则是返回this,因此 apply必须依赖对象。而由于返回了this,因此可以连续apply调用。

fun testApply() {
    val a = A()
    a.apply {
        println("如果一个对象要对它进行多个阶段的处理")
    }.apply {
        println("那么多个阶段都挤在一起则容易混淆,")
    }.apply {
        println("此时可以用apply将每一个阶段分开摆放")
    }.apply {
        println("让程序代码更加优雅")
    }
}

fun main() {
    testApply()
}

with

下面的代码应该都很眼熟,Glide图片加载框架的用法,with(context)然后链式调用

Glide.with(this).load(image).asGif().into(mImageView);

Kotlin中的with貌似把这一写法发扬光大了(只是类比,不用深究),场景如下:

class A {
    val a = 1
    val b = "b"

    fun showA() {
        println("$a")
    }

    fun showB() {
        println("$a $b")
    }
}

fun testWith() {
    val a = A()
    with(a) {
        println("作用域中可以直接引用创建出的a对象")
        this.a
        this.b
        this.showA()
        this
    }.showB()
}

fun main() {
    testWith()
}

细节

  1. with(a){} 大括号内的作用域里面,可以直接使用 当前a对象的引用,可以this.xxx 也可以 a.xxx
  2. with(a){} 大括号作用域内的最后一行是 返回值,如果我返回this,那么with结束之后,我可以继续 调用a的方法
also

also和with一样,必须依赖对象,返回值为this。因此它也支持链式调用,它和apply的区别是:

apply的block,没有参数,但是 also 则将this作为了参数。这么做造成的差异是:

作用域 { } 内调用当前对象的方式不同。

class A {
    val a = 1
    val b = "b"

    fun showA() {
        println("$a")
    }

    fun showB() {
        println("$a $b")
    }
}
fun testApply() {
    A().apply {
        this.showA()
        println("=======")
    }.showB()
}

fun testAlso() {
    A().also {
        it.showA()
        println("=======")
    }.showB()
}

apply 必须用this.xxx, also则用 it.xxx.

let

类比到run:

public inline fun <T, R> T.run(block: T.() -> R): R {
    return block()
}
public inline fun <T, R> T.let(block: (T) -> R): R {
    return block(this)
}

只有一个区别:run的block执行不需要参数,而let 的block执行时需要传入this。

造成差异为:

A().run {
    println("最后一行为返回值")
    this
}.showA()

A().let {
    println("最后一行为返回值")
    it
}.showA()

run{} 作用域中 只能通过this.xxx操作当前对象,let 则用 it.xxx

takeif 和 takeunless

这两个作用相反,并且他们必须依赖对象。看源码:

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

predicate 是 (T)->Boolean 类型的lambda表达式,表示断言判断,如果判断为true,则返回自身,否则返回空

class A {
    val a = 0
    val b = "b"

    fun showA() {
        println("$a")
    }

    fun showB() {
        println("$a $b")
    }
}

fun testTakeIfAndTakeUnless() {
    println("test takeIf")
    A().takeIf { it.a > 0 }?.showB()
    println("==========")
    println("test takeUnless")
    A().takeUnless { it.a > 0 }?.showB()
}

fun main() {
    testTakeIfAndTakeUnless()
}

执行结果:

test takeIf
==========
test takeUnless
0 b

takeIf / takeUnless适用于将条件判断的代码包在一个作用域{}中,然后 用 ?.xxxx的安全调用符 来 执行对象操作。

repeat

repeat是 多次循环的傻瓜版写法。

fun testRepeat() {
    repeat(10) {
        print("$it ")
    }
}

fun main() {
    testRepeat()
}

执行结果:

0 1 2 3 4 5 6 7 8 9 

lazy

lazy的作用是: 延迟初始化val定义的常量。

class B {
    val i: Int by lazy {
        println("执行i初始化")
        20
    }

    init {
        println("构造函数执行")
    }
}

如果只是初始化B对象,却没有使用到变量i, 那么延迟初始化不会执行。

fun main() {
    B()
}

执行结果:

构造函数执行

而如果使用到了变量i,才会去在调用之前初始化:

fun main() {
    println("i 变量的值是:" + B().i)
}

执行结果:

构造函数执行
执行i初始化
i 变量的值是:20

总结

Kotlin官方提供的高阶函数,run,apply,also,let,with等,旨在使用{}作用域,将联系紧密的代码封在一个作用域内,让一个方法内部显得 有条不紊,阅读观感更好,可维护性更高,代码更优雅。上述,除了lazy之外,所有的 函数都在Standart.kt文件内部。


延伸阅读

疫情被裁,闭关60天看完这份PDF,看我如何拿下腾讯、华为、字节跳动的offer

AsynKio:用Kotlin轻松编写您的异步网络IO调用! Asynkio:在Android上轻松编写异步IO /网络调用 | | | 与Kotlin一起无缝编写您的网络请求和IO调用。 受Python异步启发的 我的意思是.. async { // All network requests on couroutines val response = await { // Get the data val resp = get( " https://awesome.com/lib " , params = mapOf ( " lib " to " Asynkio " )) // Post the data return @await post( " https://youareonfire.com/lib " , data = mapOf ( " id " to 立即下载

相关推荐

骁龙X Elite笔记本重装Windows 11 Arm64系统完整指南与避坑手册

UEFI安全启动和Arm64架构是理解现代计算设备系统部署的基础。UEFI取代传统BIOS,提供了更安全的启动环境和模块化固件接口,而Arm64架构则以其高能效特性,在移动和新兴PC领域日益重要。其技术价值在于为设备带来更快的启动速度、更强的安全防护以及更优的功耗表现。在应用场景上,这直接关系到搭载高通骁龙X Elite等Arm处理器的笔记本电脑的系统安装与维护。对于这类设备,重装系统远非插入通用安装盘那么简单,核心挑战在于必须使用专为Arm64编译的Windows镜像,并需提前集成芯片组、网络等硬件的专属

weixin_33428613的博客 493

java协程框架_简单的理解Kotlin for Java的协程

记录一下学习的知识1.什么是协程?广义的协程是一种在程序中处理并发任务的方案; 并且协程也是这种方案的一个组件例如:适配器模式是一种方案, 而项目中又存在具体的XxxAdapter,也是一个组件广义的协程和线程属于一个层级的概念,属于并列的关系例如:如果需要异步处理任务,你可以选择线程,也可以选择协程2.什么是Kotlin for Java的协程?Kotlin for Java的协程和广义的协程并...

weixin_30618553的博客 801

如何用 Python 实现自动化测试?详细步骤和代码示例

Python自动化测试实战指南 本文系统介绍了使用Python构建自动化测试体系的完整方案。主要内容包括: 环境搭建:Python 3.8+虚拟环境配置,安装pytest、Selenium等核心测试库 分层测试实现: 单元测试:通过计算器示例演示pytest断言和异常测试 API测试:使用requests库进行RESTful接口验证 UI测试:Selenium WebDriver实现网页交互测试 高级特性: 使用fixture管理测试依赖 参数化实现数据驱动测试 生成HTML和Allure测试报告 GitH

m0_64424835的博客 454

kotlin-OKHttp网络异步请求后根据响应内容执行进一步操作

封装OKhttp package com.lettytrain.notesapp.util import okhttp3.OkHttpClient import okhttp3.Request import okhttp3.RequestBody import okhttp3.MediaType.Companion.toMediaType object OKHttpUtils { //实现cookie持久化 val client = OkHttpClient().newBuilder

sdau_clt的博客 973

quartusII简易CPU设计

优点可以实现八种运算,数据的存取及运算都能很好的实现,上板也很成功。缺点首先由于自己知识储备的缺乏,只能实现较为简单的8种运算,也是最简单的直接寻址。其次为了方便操作,没有从外部输入数据,都是直接使用存储在存储器中的数据。后续发展后续会在此简易CPU的基础上增加一些功能对CPU进行完善,如算术运算可以考虑是补码运算,输入、输出采用存储缓冲等等,直至完整的全功能的处理器。收获通过这次实践,更熟悉Quartus软件的操作。能过更加清楚每个器件的操作,比如计数器,运算器,译码器等的实现功能。

Kong08242022的博客 3484

k8s 查看cpu使用率最高的pod

在 Kubernetes 中,可以使用命令查看 Pod 的资源使用情况,从而找到 CPU 使用率最高的 Pod。

u010674101的专栏 3347

[Android]网络框架之OkHttp(详细)(kotlin)

由Square公司贡献的一个处理网络请求的开源项目,是目前Android使用最广泛的网络框架。从Android4.0开始HttpURLConnection的底层实现采用的是OkHttp。OkHttp的介绍,添加依赖,OkHttp的使用get的同步与异步请求post的同步与异步请求POST请求的数据格式POST请求上传文件POST请求上传json对象POST请求上传多个数据OkHttp的配置1.Builder构建器2.自定义拦截器3.自定义缓存4. 自定义Cookie

weixin_63357306的博客 1万+

用PyCharm+Scrapy打造你的第一个爬虫:从安装到实战(附完整代码)

本文详细介绍了如何使用PyCharm和Scrapy框架从零开始构建高效网络爬虫。通过环境配置、项目创建、核心爬虫逻辑编写到数据处理与存储的完整流程,帮助Python开发者快速掌握爬虫开发技巧,并附有实战代码示例。特别适合想要学习Scrapy框架和提升爬虫技能的开发者。

weixin_29038345的博客 869

解决使用kotlin编写OkHttp的网络请求时遇到的OOM问题

一、背景介绍: 问题的出现是因为我的代码中需要进行网络请求,而网络请求又是在一个线程中,间隔几秒就会请求一次,为了方便,就是用的OkHttp进行网络访问,本来,是没问题的,谁知道,某次测试时间长了一点,然后apk就突然闪退了,看了下log,是因为大量创建了线程,栈被撑爆了,OOM,遂卒~,通过网上找资料,最终查明原因是OkHttp的client没有进行单实例封装,每发一次请求,就会创建一个线程池,最终OOM,下面就这个问题,单独写了一个demo进行问题模拟及解决。 二、模拟复现: 1.OkHttp的异步访问

achina2011jy的博客 2029

R语言实战:从Raw Counts到TPM/FPKM的完整转换指南(含代码调试技巧)

本文详细介绍了在R语言环境中将RNA-seq原始计数(raw counts)转换为TPM/FPKM值的完整流程,包含代码实现和常见错误调试技巧。通过具体案例演示如何正确处理基因长度和测序深度因素,实现表达量标准化,为生物信息学分析提供可靠数据基础。特别适合需要进行转录组数据分析的研究人员和实验室技术人员参考。

weixin_28559803的博客 481

Mac安装Typescript报错

根本原因是系统级目录的权限限制。推荐通过修改目录权限或使用nvm彻底解决问题。

江拥羡橙的博客 211

Kotlin(1)-lambda表达式和高阶函数操作符

当lambda表达式作为方法的最后一个参数时,可以lambda表达式放到小括号外面。而如果只有一个参数就是lambda表达式,那么括号可以省略这个非常重要,不了解这个,很多地方都会感觉很蛋疼。println(s)block()block()testLambda(“第一个参数”) {println(“block函数体”)“返回值”println(“block函数体”)“返回值”Kotlin中lambda表达式可以当作普通参数一样去传递,去赋值,去使用。

2401_84408337的博客 970

YOLOv8【第九章:模型部署篇·第2节】一文搞懂,模型剪枝与压缩技术!

🏆 本文收录于 《YOLOv8实战:从入门到深度优化》 专栏。该专栏系统复现并梳理全网各类 YOLOv8 改进与实战案例(当前已覆盖分类 / 检测 / 分割 / 追踪 / 关键点 / OBB 检测等方向),坚持持续更新 + 深度解析,质量分长期稳定在 97 分以上,可视为当前市面上 覆盖较全、更新较快、实战导向极强 的 YOLO 改进系列内容之一。

**My Coding Family** 1530

Kotlin-29-高阶函数、匿名函数、Lambda简化Java函数

目录 1、Java原型 2、高阶函数简化Java函数 2.1、:: 的作用 3、匿名函数简化Java函数 4、Lambda简化Java函数 1、Java原型 现在假设这么一种情况,我们有一个人员的List我们需要筛选出这个List中年龄大于指定年龄的人的List,那么先来看一下普通实现。 fun main() { //模拟出人员List val personLi...

Yo.o 447

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

高阶函数与labmda表达式

提纲 高阶函数 定义:高阶函数是将函数用作参数或返回值的函数 其实理解一个新东西,定义是特别重要的,上述定义是kotlin官方文档给出的,它描述了高阶函数是什么,接受了这个定义就不会畏难了。通过上述定义知道高阶函数和函数的区别是输入参数可以是函数,返回值也可以是函数。 组成 函数由输入输出组成 输入 普通类型实例 函数类型实例 输出 普通类型实例 函数类型实例 函数类型:定义一个函数 (A,B) -> C:用普通函数定义,输入为A,B输出为C A.(B) -> C:用扩展函数定义 挂

yueyue_projects的专栏 462

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

kotlin + dagger2 + rxjava

kotlinhttps://huanglizhuo.gitbooks.io/kotlin-in-chinese/content/FunctionsAndLambdas/Higher-OrderFunctionsAndLambdas.htmldagger2:https://www.imooc.com/article/22622rxjava:http://gank.io/post/560e15be2d...

qq_33994844的博客 353

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Kotlin中的Lambda表达式

对程序员来说,很多技术的学习都是“防御性”的。也就是说,我们是在为未来学习。我们学习新技术的目的,或是为了在新项目中应用,或仅仅是为了将来的面试。但不管怎样,一定不能“止步不前”,不能荒废掉。!文章以下内容会给出阿里与美团的面试题(答案+解析)、面试题库、Java核心知识点梳理等《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》点击传送门,即可获取!188901)][外链图片转存中…(img-hCRK9nBC-1715490188902)]

2401_84412521的博客 1228

彻底搞懂Kotlin的高阶函数、匿名函数、Lambda表达式

在Kotlin还没成为Android开发首选语言之前,我们一直是使用Java语言来开发Android应用。不过对于Lambda来说,大家应该并不陌生,因为Android Studio也可以支持JAVA 8中的Lambda表达式,只需要在app的build.gradle中添加以下代码: android { // ... compileOptions { targetCompatibility JavaVersion.VERSION_1_8 sourceCompa

HurryYu的博客 1238

Kotlin系列之Lambda表达式完全解析

简述: 今天带来的Kotlin浅谈系列的第六弹, 一起来聊下Kotlin中的lambda表达式。lambda表达式应该都不陌生,在Java8中引入的一个很重要的特性,将开发者从原来繁琐的语法中解放出来,可是很遗憾的是只有Java8版本才能使用。而Kotlin则弥补了这一问题,Kotlin中的lambda表达式与Java混合编程可以支持Java8以下的版本。那我们带着以下几个问题一起来看下Kotli...

Mikyou的专栏 1万+

Kotlin高阶函数及Lambda表达式解析

在网上关于Kotlin的高阶函数和Lambda表达式的讲解大部分来自于Kotlin的官方文档,个人认为比较晦涩难懂。 本文从我的个人理解角度讲解一下应该如何理解高阶函数和Lambda表达式,希望能对正在学习Kotlin的同学有所帮助。 高阶函数是将函数用作参数或返回值的函数。 这是官方对高阶函数的定义,那么要理解高阶函数,第一要明确的概念是,在Kotlin里函数可以作为一种变量类型存在!!!

狂暴棕熊的博客 676
上一篇: HTTPS 原理分析——带着疑问层层深入
下一篇: 如何更高效的使用MVP以及官方MVP架构解析
Python_林一
博客等级 码龄7年 889粉丝 510原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值