1.2、将函数用作一个函数的返回值的高阶函数
这里使用官网上的一个例子来讲解。lock()
函数,先看一看他的源码实现
fun lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
}
finally {
lock.unlock()
}
}
源码说明:
- 这其中用到了
kotlin
中泛型
的知识点,这里不考虑。我会在后续的文章为大家讲解。 - 从源码可以看出,该函数接受一个
Lock
类型的变量作为参数1
,并且接受一个无参且返回类型为T
的函数作为参数2
. - 该函数的返回值为一个函数,我们可以看这一句代码
return body()
可以看出。
例:使用lock
函数,下面的代码都是伪代码,我就是按照官网的例子直接拿过来用的
fun toBeSynchronized() = sharedResource.operation()
val result = lock(lock, ::toBeSynchronized)
其中,::toBeSynchronized
即为对函数toBeSynchronized()
的引用,其中关于双冒号::
的使用在这里不做讨论与讲解。
上面的写法也可以写作:
val result = lock(lock, {sharedResource.operation()} )
1.3、高阶函数的使用
在上面的两个例子中,我们出现了str.sumBy{ it.toInt }
这样的写法。其实这样的写法在前一章节Lambda使用
中已经讲解过了。这里主要讲高阶函数中对Lambda语法
的简写。
从上面的例子我们的写法应该是这样的:
str.sumBy( { it.toInt } )
但是根据Kotlin
中的约定,即当函数中只有一个函数作为参数,并且您使用了lambda
表达式作为相应的参数,则可以省略函数的小括号()
。故而我们可以写成:
str.sumBy{ it.toInt }
还有一个约定,即当函数的最后一个参数是一个函数,并且你传递一个lambda
表达式作为相应的参数,则可以在圆括号之外指定它。故而上面例2
中的代码我们可写成:
val result = lock(lock){
sharedResource.operation()
}
二、自定义高阶函数
我们先看了一个例子:
// 源代码
fun test(a : Int , b : Int) : Int{
return a + b
}
fun sum(num1 : Int , num2 : Int) : Int{
return num1 + num2
}
// 调用
test(10,sum(3,5)) // 结果为:18
// lambda
fun test(a : Int , b : (num1 : Int , num2 : Int) -> Int) : Int{
return a + b.invoke(3,5)
}
// 调用
test(10,{ num1: Int, num2: Int -> num1 + num2 }) // 结果为:18
可以看出上面的代码中,直接在我的方法体中写死了数值,这在开发中是很不合理的,并且也不会这么写。上面的例子只是在阐述Lambda
的语法。接下来我另举一个例子:
例:传入两个参数,并传入一个函数来实现他们不同的逻辑
private fun resultByOpt(num1 : Int , num2 : Int , result : (Int ,Int) -> Int) : Int{
return result(num1,num2)
}
fun main() {
val result1 = resultByOpt(1,2){
num1, num2 -> num1 + num2
}
val result2 = resultByOpt(3,4){
num1, num2 -> num1 - num2
}
val result3 = resultByOpt(5,6){
num1, num2 -> num1 * num2
}
val result4 = resultByOpt(6,3){
num1, num2 -> num1 / num2
}
println(“result1 =
r
e
s
u
l
t
1
"
)
p
r
i
n
t
l
n
(
"
r
e
s
u
l
t
2
=
result1") println("result2 =
result1")println("result2 = result2”)
println(“result3 =
r
e
s
u
l
t
3
"
)
p
r
i
n
t
l
n
(
"
r
e
s
u
l
t
4
=
result3") println("result4 =
result3")println("result4 = result4”)
}
输出结果为:
result1 = 3
result2 = -1
result3 = 30
result4 = 2
这个例子是根据传入不同的Lambda
表达式,实现了两个数的+、-、*、/
。
三、常用的标准高阶函数介绍
下面介绍几个Kotlin
中常用的标准高阶函数。熟练的用好下面的几个函数,能减少很多的代码量,并增加代码的可读性。下面的几个高阶函数的源码几乎上都出自Standard.kt
文件
3.1、TODO函数
这个函数不是一个高阶函数,它只是一个抛出异常以及测试错误的一个普通函数。
此函数的作用:显示抛出
NotImplementedError
错误。NotImplementedError
错误类继承至Java
中的Error
。我们看一看他的源码就知道了:
public class NotImplementedError(message: String = “An operation is not implemented.”) : Error(message)
TODO
函数的源码
@kotlin.internal.InlineOnly
public inline fun TODO(): Nothing = throw NotImplementedError()
@kotlin.internal.InlineOnly
public inline fun TODO(reason: String): Nothing =
throw NotImplementedError(“An operation is not implemented: $reason”)
举例说明:
fun main(args: Array) {
TODO(“测试TODO函数,是否显示抛出错误”)
}
输出结果为:
如果调用TODO()
时,不传参数的,则会输出An operation is not implemented.
3.2 、run()函数
run
函数这里分为两种情况讲解,因为在源码中也分为两个函数来实现的。采用不同的run
函数会有不同的效果。
3.2.1、run()
我们看下其源码:
public inline fun run(block: () -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
关于contract
这部分代码小生也不是很懂其意思。在一些大牛的blog
上说是其编辑器对上下文的推断。但是我也不知道对不对,因为在官网中,对这个东西也没有讲解到。不过这个单词的意思是契约,合同
等等意思。我想应该和这个有关。在这里我就不做深究了。主要讲讲run{}
函数的用法其含义。
这里我们只关心return block()
这行代码。从源码中我们可以看出,run
函数仅仅是执行了我们的block()
,即一个Lambda
表达式,而后返回了执行的结果。
用法1:
当我们需要执行一个
代码块
的时候就可以用到这个函数,并且这个代码块是独立的。即我可以在run()
函数中写一些和项目无关的代码,因为它不会影响项目的正常运行。
例: 在一个函数中使用
private fun testRun1() {
val str = “kotlin”
run{
val str = “java” // 和上面的变量不会冲突
println(“str = $str”)
}
println(“str = $str”)
}
输出结果:
str = java
str = kotlin
用法2:
因为
run
函数执行了我传进去的lambda
表达式并返回了执行的结果,所以当一个业务逻辑都需要执行同一段代码而根据不同的条件去判断得到不同结果的时候。可以用到run
函数
例:都要获取字符串的长度。
val index = 3
val num = run {
when(index){
0 -> “kotlin”
1 -> “java”
2 -> “php”
3 -> “javaScript”
else -> “none”
}
}.length
println(“num = $num”)
输出结果为:
num = 10
3.2.2、T.run()
其实T.run()
函数和run()
函数差不多,关于这两者之间的差别我们看看其源码实现就明白了:
public inline fun <T, R> T.run(block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
从源码中我们可以看出,block()
这个函数参数是一个扩展在T
类型下的函数。这说明我的block()
函数可以可以使用当前对象的上下文。所以当我们传入的lambda
表达式想要使用当前对象的上下文的时候,我们可以使用这个函数。
例:
val str = “kotlin”
str.run {
println( “length =
t
h
i
s
.
l
e
n
g
t
h
"
)
p
r
i
n
t
l
n
(
"
f
i
r
s
t
=
{this.length}" ) println( "first =
this.length" )println( "first = {first()}”)
println( “last = ${last()}” )
}
输出结果为:
length = 6
first = k
last = n
在其中,可以使用this
关键字,因为在这里它就代码str
这个对象,也可以省略。因为在源码中我们就可以看出,block()
就是一个T
类型的扩展函数。
这在实际的开发当中我们可以这样用:
例: 为TextView
设置属性。
val mTvBtn = findViewById(R.id.text)
mTvBtn.run{
text = “kotlin”
textSize = 13f
…
}
3.3 、with()函数
其实with()
函数和T.run()
函数的作用是相同的,我们这里看下其实现源码:
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return receiver.block()
}
这两个函数的区别在于:
with
是正常的高阶函数,T.run()
是扩展的高阶函数。with
函数的返回值指定了receiver
为接收者。
例:实现上面的T.run()
函数的列子
val str = “kotlin”
with(str) {
println( “length =
t
h
i
s
.
l
e
n
g
t
h
"
)
p
r
i
n
t
l
n
(
"
f
i
r
s
t
=
{this.length}" ) println( "first =
this.length" )println( "first = {first()}”)
println( “last = ${last()}” )
}
输出结果为:
length = 6
first = k
last = n
例:当我的对象可为null
的时候,看两个函数之间的便利性
val newStr : String? = “kotlin”
with(newStr){
println( “length =
t
h
i
s
?
.
l
e
n
g
t
h
"
)
p
r
i
n
t
l
n
(
"
f
i
r
s
t
=
{this?.length}" ) println( "first =
this?.length" )println( "first = {this?.first()}”)
println( “last = ${this?.last()}” )
}
newStr?.run {
println( “length =
l
e
n
g
t
h
"
)
p
r
i
n
t
l
n
(
"
f
i
r
s
t
=
length" ) println( "first =
length" )println( "first = {first()}”)
println( “last = ${last()}” )
}
从上面的代码我们就可以看出,当我们使用对象可为null
时,使用T.run()
比使用with()
函数从代码的可读性与简洁性来说要好一些。当然关于怎样去选择使用这两个函数,就得根据实际的需求以及自己的喜好了。
3.4、T.apply()函数
我们先看下T.apply()
函数的源码:
public inline fun T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
从T.apply()
源码中在结合前面提到的T.run()
函数的源码我们可以得出,这两个函数的逻辑差不多,唯一的区别是T,apply
执行完了block()
函数后,返回了自身对象。而T.run
是返回了执行的结果。
故而: T.apply
的作用除了实现能实现T.run
函数的作用外,还可以后续的再对此操作。下面我们看一个例子
例:为TextView
设置属性后,再设置点击事件等
val mTvBtn = findViewById(R.id.text)
mTvBtn.apply{
text = “kotlin”
textSize = 13f
…
}.apply{
// 这里可以继续去设置属性或一些TextView的其他一些操作
}.apply{
setOnClickListener{ … }
}
或者:设置为Fragment
设置数据传递
// 原始方法
fun newInstance(id : Int , name : String , age : Int) : MimeFragment{
val fragment = MimeFragment()
fragment.arguments?.putInt(“id”,id)
fragment.arguments?.putString(“name”,name)
fragment.arguments?.putInt(“age”,age)
return fragment
}
// 改进方法
fun newInstance(id : Int , name : String , age : Int) = MimeFragment().apply {
arguments = Bundle()
arguments?.putInt(“id”,id)
arguments?.putString(“name”,name)
arguments?.putInt(“age”,age)
}
3.5、T.also()函数
关于T.also
函数来说,它和T.apply
很相似,。我们先看看其源码的实现:
public inline fun T.also(block: (T) -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block(this)
return this
}
从上面的源码在结合T.apply
函数的源码我们可以看出: T.also
函数中的参数block
函数传入了自身对象。故而这个函数的作用是用用block
函数调用自身对象,最后在返回自身对象
这里举例一个简单的例子,并用实例说明其和T.apply
的区别
例:
“kotlin”.also {
println(“结果:KaTeX parse error: Expected 'EOF', got '}' at position 24: …("-java")}") }̲.also { print…{it.plus(”-php")}")
}
“kotlin”.apply {
println(“结果:KaTeX parse error: Expected 'EOF', got '}' at position 26: …("-java")}") }̲.apply { prin…{this.plus(”-php")}")
}
他们的输出结果是相同的:
结果:kotlin-java
结果:kotlin-php
结果:kotlin-java
结果:kotlin-php
从上面的实例我们可以看出,他们的区别在于,T.also
中只能使用it
调用自身,而T.apply
中只能使用this
调用自身。因为在源码中T.also
是执行block(this)
后在返回自身。而T.apply
是执行block()
后在返回自身。这就是为什么在一些函数中可以使用it
,而一些函数中只能使用this
的关键所在
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
如果你进阶的路上缺乏方向,可以加入我们的圈子和安卓开发者们一起学习交流!
-
Android进阶学习全套手册
-
Android对标阿里P7学习视频
-
BATJ大厂Android高频面试题
最后,借用我最喜欢的乔布斯语录,作为本文的结尾:
人这一辈子没法做太多的事情,所以每一件都要做得精彩绝伦。
你的时间有限,所以不要为别人而活。不要被教条所限,不要活在别人的观念里。不要让别人的意见左右自己内心的声音。
最重要的是,勇敢的去追随自己的心灵和直觉,只有自己的心灵和直觉才知道你自己的真实想法,其他一切都是次要。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
一起学习交流!**
-
Android进阶学习全套手册
[外链图片转存中…(img-67MKcnSg-1712781202878)]
-
Android对标阿里P7学习视频
[外链图片转存中…(img-WIowssbC-1712781202878)]
-
BATJ大厂Android高频面试题
[外链图片转存中…(img-zNQF7zG6-1712781202878)]
最后,借用我最喜欢的乔布斯语录,作为本文的结尾:
人这一辈子没法做太多的事情,所以每一件都要做得精彩绝伦。
你的时间有限,所以不要为别人而活。不要被教条所限,不要活在别人的观念里。不要让别人的意见左右自己内心的声音。
最重要的是,勇敢的去追随自己的心灵和直觉,只有自己的心灵和直觉才知道你自己的真实想法,其他一切都是次要。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!