标准库里面常用的高阶函数的定义和用法
T.apply()函数
调用某对象的apply函数，在函数范围内，可以通过this调用该对象的任意方法，并返回该对象，this可以省略不写.
apply一般用于一个对象实例初始化的时候，需要对对象中的属性进行赋值。
函数的源码：
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
使用
fun main() {
val result = UserEntity().apply {
this.userId = 100
this.userName = "华晨宇"
this.age = 30
println("my name is $userName, I am $age years old, my number is $userId")
}
println("result: $result")
}
输出
my name is 华晨宇, I am 30 years old, my number is 100
result: userName:华晨宇,userId:100,age:30
T.let()函数
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}
let函数默认当前这个对象作为闭包的it参数，返回值是函数里面最后一行，或者指定return
fun main() {
"kotlin".let {
println("原字符串：$it") // kotlin
it.reversed()
}.let {
println("反转字符串后的值：$it") // niltok
it.plus("-java")
}.let {
println("新的字符串：$it") // niltok-java
}
}
输出
原字符串：kotlin
反转字符串后的值：niltok
新的字符串：niltok-java
T.also()函数
public inline fun <T> T.also(block: (T) -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block(this)
return this
}
also函数的结构实际上和let很像唯一的区别就是返回值的不一样，let是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身
fun main() {
val result = "kotlin".also {
println("结果：${it.plus("-java")}")
}.also {
println("结果：${it.plus("-php")}")
}
println("result：$result")
}
结果：kotlin-java
结果：kotlin-php
result：kotlin
T.run()函数
public inline fun <T, R> T.run(block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
在函数范围内，可以任意调用该对象的任意方法，返回函数里面最后一行，或者指定return
fun main() {
val str = "kotlin"
str.run {
println("length = ${this.length}")
println("first = ${first()}")
println("last = ${last()}")
}
}
length = 6
first = k
last = n
fun main() {
val result = UserEntity().run {
this.userId = 100
this.userName = "华晨宇"
this.age = 30
println("my name is $userName, I am $age years old, my number is $userId")
userName
}
println("result: $result")
}
my name is 华晨宇, I am 30 years old, my number is 100
result: 华晨宇
with()函数
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return receiver.block()
}
with函数接收两个参数，一个是调用者，第二个为一个函数，在函数库内可以通过this指代调用者（第一个参数）来调用，返回值为函数块的最后一行或指定return
fun main() {
val newStr = "kotlin"
val result = with(newStr){
println( "length = ${this.length}" )
println( "first = ${this.first()}")
println( "last = ${this.last()}" )
length
}
println("result: $result")
}
length = 6
first = k
last = n
result: 6
T.takeIf()函数
public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
contract {
callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
}
return if (predicate(this)) this else null
}
传入一个你希望的一个条件，如果对象符合你的条件则返回自身，反之，则返回null
fun main() {
val str = "kotlin"
val result = str.takeIf {
//it.startsWith("ko")
it.startsWith("java")
}
println("result = $result")
}
result = kotlin
result = null
T.takeUnless()函数
public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
contract {
callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
}
return if (!predicate(this)) this else null
}
如果对象符合你的条件则返回null，反之，则返回自身
fun main() {
val list = listOf(
UserEntity(100, "华晨宇", 30),
UserEntity(101, "张碧晨", 31),
UserEntity(103, "邓紫棋", 29),
UserEntity(103, "李宇春", 32)
)
for (entity in list) {
val result = entity.takeUnless {
it.age > 30
}
println("result = $result")
}
}
result = userName:华晨宇,userId:100,age:30
result = null
result = userName:邓紫棋,userId:103,age:29
result = null
repeat()函数
public inline fun repeat(times: Int, action: (Int) -> Unit) {
contract { callsInPlace(action) }
for (index in 0..times - 1) {
action(index)
}
}
就是重复某操作指定次数
fun main() {
val list = listOf(
UserEntity(100, "华晨宇", 30),
UserEntity(101, "张碧晨", 31),
UserEntity(103, "邓紫棋", 29),
UserEntity(103, "李宇春", 32)
)
for (entity in list) {
if (entity.age < 30) {
repeat(3) {
println(entity)
}
}
}
}
userName:邓紫棋,userId:103,age:29
userName:邓紫棋,userId:103,age:29
userName:邓紫棋,userId:103,age:29
lazy()函数
public fun <T> lazy(initializer: () -> T): Lazy<T>
public fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T>
public fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T>
这是一个提供延时加载能力的代理属性，接受一个lambda并返回一个Lazy <T>实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用 get()会执行已传递给lazy()的lambda表达式并记录结果， 后续调用 get()只是返回记录的结果。
fun main() {
val lazyValue: UserEntity by lazy {
println("lazy!")
UserEntity(100, "华晨宇", 30)
}
//第一次访问lazyValue，会打印"lazy!"和"华晨宇"
println(lazyValue)
//第二次访问只打印结果"华晨宇"
println(lazyValue)
}
lazy!
userName:华晨宇,userId:100,age:30
userName:华晨宇,userId:100,age:30
