Kotlin学习笔记：4.4、内置函数_kotlin的内置函数详细使用

一、什么是内置函数？

在 Kotlin 中，内置函数（Built-in Functions）是指已经定义好并包含在 Kotlin 标准库中的函数。这些函数可以直接使用，而不需要进行任何额外的导入或配置。这些内置函数涵盖了广泛的主题，包括字符串操作、集合处理、文件操作等等。

内置函数包括两种类型：扩展函数和普通函数。扩展函数是指针对某个类型的函数，可以像该类型的成员函数一样调用。普通函数是指不属于任何类型的函数，可以直接通过包名访问。

Kotlin 的内置函数非常丰富且灵活，它们可以帮助开发人员提高开发效率，简化代码编写过程，并提供常用功能的实现。

二、举例说明一下内置扩展函数和内置普通函数

下面是一些 Kotlin 内置扩展函数和内置普通函数的示例：

内置扩展函数示例：

// 扩展函数：let()
val nullableString: String? = "Hello"
nullableString?.let { 
    // 对可空字符串进行安全调用，避免 NPE
    println(it) // 输出 "Hello"
}

// 扩展函数：capitalize()
val str = "hello world"
val capitalizedStr = str.capitalize()
println(capitalizedStr) // 输出 "Hello world"

1
2
3
4
5
6
7
8
9
10
11
12

在上面的代码中，我们使用了 let() 和 capitalize() 两个扩展函数。let() 函数用于避免空指针异常（NPE），capitalize() 函数用于将字符串的第一个字符转换为大写字母。

内置普通函数示例：

// 普通函数：println()
val str = "Hello world"
println(str) // 输出 "Hello world"

// 普通函数：readLine()
println("What's your name?")
val name = readLine() // 读取用户输入的名称
println("Hello, $name!") // 输出 "Hello, 用户输入的名称！"

1
2
3
4
5
6
7
8
9

在上面的代码中，我们使用了 println() 和 readLine() 两个普通函数。println() 函数用于将内容输出到控制台，readLine() 函数用于从控制台读取用户输入的内容。

需要注意的是，无论是扩展函数还是普通函数，它们都已经被包含在 Kotlin 的标准库中，因此可以直接使用，无需导入或配置

三、内置扩展函数

3.1、数组类型的扩展函数：

plus()：用于将两个数组合并成一个数组。
minus()：用于从数组中移除指定元素，并返回新的数组。
slice()：用于获取数组中指定位置的元素，并返回新的数组。
chunked()：用于将数组分成指定大小的块，并返回一个列表。
distinct()：用于获取数组中不同的元素，并返回新的数组。
find()：用于在数组中查找符合指定条件的元素，并返回该元素。
joinToString()：用于将数组中的元素连接成字符串，并返回该字符串。
map()：用于根据指定规则将数组中的元素进行映射，并返回一个新的数组。
sum()：用于计算数组中所有元素的和。
first()：返回第一个元素
last()：返回最后一个元素
firstOrNull()：返回第一个元素，如果数组为空则返回null
lastOrNull()：返回最后一个元素，如果数组为空则返回null
getOrNull()：根据下标获取元素，如果下标越界则返回null
take()：获取前n个元素
takeLast()：获取后n个元素
drop()：去除前n个元素
dropLast()：去除后n个元素
filter()：根据条件筛选元素
map()：对每个元素执行指定操作
flatMap()：对每个元素执行指定操作，并将结果合并到一个列表中
distinct()：去除重复元素
distinctBy()：根据指定条件去除重复元素
contains()：判断数组是否包含指定元素
indexOf()：获取指定元素的下标，如果不存在则返回-1
lastIndexOf()：获取指定元素的最后一个下标，如果不存在则返回-1
partition()：根据条件分成两个数组
groupBy()：根据条件将元素分组到不同的数组中
sum()：计算元素的总和
average()：计算元素的平均值
max()：获取最大元素
min()：获取最小元素
reduce()：对元素进行累加
fold()：对元素进行累加，并可以指定初始值
forEach()：遍历元素并执行指定操作
forEachIndexed()：遍历元素并获取索引，执行指定操作
zip()：将两个数组合并成一个新数组，每个元素都是一对。
all()：判断所有元素是否都满足指定条件
any()：判断是否有任何元素满足指定条件
none()：判断是否所有元素都不满足指定条件
associate()：将每个元素转化为Pair对象，并返回一个Map
associateBy()：根据指定条件生成key，并将元素转化为value，返回一个Map
associateWith()：将每个元素转化为key，并根据指定条件生成value，返回一个Map
flatMapTo()：将每个元素执行指定操作，并将结果合并到一个指定类型的列表中
mapTo()：将每个元素执行指定操作，并将结果合并到一个指定类型的列表中
reduceIndexed()：对元素进行累加，并可以访问索引
foldIndexed()：对元素进行累加，并可以访问索引，并可以指定初始值
sort()：对元素进行排序
sortBy()：根据指定条件对元素进行排序
sortDescending()：对元素进行降序排序
sortedByDescending()：根据指定条件对元素进行降序排序
zipWithNext()：将相邻的两个元素合并为一对，返回一个新数组
union()：将两个数组合并为一个新数组，去除重复元素
intersect()：返回两个数组中的交集元素
subtract()：返回从当前数组中删除另一个数组中的元素后得到的数组
下是一些数组删除元素的扩展函数：
dropWhile()：返回一个新数组，包含从指定位置开始的所有元素，直到第一个不满足指定条件的元素
dropLastWhile()：返回一个新数组，包含从开始到指定位置的所有元素，直到第一个不满足指定条件的元素
filterIndexed()：返回一个新数组，包含满足指定条件的元素及其索引
filterNot()：返回一个新数组，不包含满足指定条件的元素
filterNotNull()：返回一个新数组，不包含null元素
take()：返回一个新数组，包含从开始到指定位置的所有元素，包括指定位置
takeWhile()：返回一个新数组，包含从开始到第一个不满足指定条件的元素的所有元素
takeLast()：返回一个新数组，包含从指定位置到末尾的所有元素，包括指定位置
takeLastWhile()：返回一个新数组，包含从指定位置到最后一个满足指定条件的元素的所有元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

等。

3.2、字符串类型的扩展函数：

contains()：判断字符串是否包含指定字符序列
endsWith()：判断字符串是否以指定字符序列结尾
startsWith()：判断字符串是否以指定字符序列开头
padStart()：在字符串开头添加指定数量的字符，以达到指定长度
padEnd()：在字符串结尾添加指定数量的字符，以达到指定长度
repeat()：将字符串重复指定次数
isNullOrEmpty()：判断字符串是否为null或空字符串
isNullOrBlank()：判断字符串是否为null或仅包含空格字符
plus()：将两个字符串拼接成一个新字符串
toCharArray()：将字符串转换为字符数组
indexOf()：返回字符串中指定字符或子字符串的第一个出现位置的索引值
lastIndexOf()：返回字符串中指定字符或子字符串的最后一个出现位置的索引值
replace()：替换字符串中所有匹配指定正则表达式的字符或子字符串
split()：将字符串按指定字符或正则表达式分割为数组
toBigDecimal()：将字符串转换为BigDecimal类型
toInt()：将字符串转换为Int类型
toLong()：将字符串转换为Long类型
toFloat()：将字符串转换为Float类型
toDouble()：将字符串转换为Double类型
capitalize()：将字符串的第一个字符转换为大写字母
decapitalize()：将字符串的第一个字符转换为小写字母
toLowerCase()：将字符串中的所有字符转换为小写字母
toUpperCase()：将字符串中的所有字符转换为大写字母
substringBefore()：返回字符串中指定字符或子字符串之前的部分
substringAfter()：返回字符串中指定字符或子字符串之后的部分
joinToString()：将集合转换为字符串，并将元素用指定的分隔符分隔
take()：返回字符串的前n个字符
drop()：返回去除字符串前n个字符之后的新字符串
slice()：返回指定范围内的字符或子字符串
reverse()：反转字符串中的字符顺序
toRegex()：将字符串转换为正则表达式
matches()：判断字符串是否与指定的正则表达式匹配
replaceFirst()：替换字符串中第一个匹配指定正则表达式的字符或子字符串
replaceAll()：替换字符串中所有匹配指定正则表达式的字符或子字符串
count()：返回字符串中指定字符或子字符串的出现次数
chunked()：将字符串按照指定的大小分块，并返回一个块的列表
windowed()：返回一个滑动窗口，其中包含指定大小的元素，可以指定滑动步长
trim()：去除字符串首尾的空白字符
trimStart()：去除字符串开头的空白字符
trimEnd()：去除字符串结尾的空白字符
substring()：获取字符串的子串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3.3、集合类型的扩展函数：

Kotlin中的集合类型（Collection、List、Set等）也提供了很多有用的扩展函数，下面是一些常用的扩展函数：

forEach()：遍历集合并对其中每个元素执行给定的操作
filter()：根据给定的条件过滤集合中的元素
map()：将集合中每个元素按照给定的规则进行转换
flatMap()：将集合中每个元素按照给定的规则进行转换，然后合并成一个新的集合
distinct()：去除集合中的重复元素
sorted()：对集合进行排序
groupBy()：根据给定的规则对集合中的元素进行分组
partition()：根据给定的条件将集合分成两部分
associateBy()：根据给定的规则将集合中的元素转换为键值对
zip()：将两个集合中的元素逐个配对，返回一个包含每个配对的Pair的新集合
indexOfFirst()：返回集合中第一个符合给定条件的元素的索引值
firstOrNull()：返回集合中第一个元素或null
lastOrNull()：返回集合中最后一个元素或null
getOrElse()：获取指定位置的元素，如果不存在则返回默认值
all()：判断集合中所有元素是否都符合给定条件
any()：判断集合中是否存在符合给定条件的元素
count()：返回符合给定条件的元素数量
find()：返回集合中第一个符合给定条件的元素
indexOfLast()：返回集合中最后一个符合给定条件的元素的索引
joinToString()：将集合转换为一个字符串
max()：返回集合中的最大值
min()：返回集合中的最小值
reduce()：将集合中的元素进行累计操作
sum()：对集合中的元素进行求和
associate()：通过对集合中的元素进行转换来创建一个键值对集合
mapIndexed()：对集合中的元素进行操作，并返回操作结果组成的集合，同时可以获取元素的索引
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.4、迭代器类型的扩展函数：

all()：判断迭代器中的所有元素是否都满足给定的条件
any()：判断迭代器中是否有至少一个元素满足给定的条件
asSequence()：将迭代器转换为一个序列
count()：返回迭代器中的元素数量
distinct()：返回迭代器中所有不同的元素
drop()：丢弃前 n 个元素，返回剩余的元素组成的迭代器
filter()：根据给定的条件筛选迭代器中的元素
flatMap()：对迭代器中的每个元素进行操作，并返回操作结果组成的新的迭代器
flatten()：将嵌套迭代器展开为一个扁平的迭代器
fold()：对迭代器中的元素进行累积操作，返回最终结果
forEach()：对迭代器中的每个元素进行操作
groupBy()：根据给定的条件对迭代器中的元素进行分组
indexOf()：返回迭代器中第一个满足给定条件的元素的索引
map()：对迭代器中的每个元素进行操作，并返回操作结果组成的新的迭代器
max()：返回迭代器中的最大值
min()：返回迭代器中的最小值
none()：判断迭代器中是否没有任何元素满足给定的条件
reduce()：对迭代器中的元素进行累积操作，返回最终结果
sorted()：返回一个按照升序排序的迭代器
sum()：计算迭代器中所有元素的总和
take()：返回前 n 个元素组成的迭代器
takeWhile()：从迭代器中取出符合条件的元素，一旦遇到第一个不符合条件的元素就停止
toList()：将迭代器中的元素转换为一个列表
toSet()：将迭代器中的元素转换为一个集合
withIndex()：返回一个迭代器，该迭代器产生一个由每个元素及其索引组成的 Pair
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.5、类型转换的扩展函数：

toInt(): 将字符串转换为整型
toFloat(): 将字符串转换为浮点型
toLong(): 将字符串转换为长整型
toShort(): 将字符串转换为短整型
toDouble(): 将字符串转换为双精度浮点型
toBigDecimal(): 将字符串转换为 BigDecimal 类型
toBigInteger(): 将字符串转换为 BigInteger 类型

toString(): 将任意类型转换为字符串
toBoolean(): 将字符串转换为布尔型
toByte(): 将字符串转换为字节型
toChar(): 将字符串转换为字符型
toUByte(): 将字符串转换为无符号字节型
toUInt(): 将字符串转换为无符号整型
toULong(): 将字符串转换为无符号长整型
toUShort(): 将字符串转换为无符号短整型
toByteArray(): 将字符串转换为字节数组
toTypedArray(): 将集合转换为数组
toCollection(): 将数组转换为集合类型
toSet(): 将数组或集合转换为集合类型，并去除重复元素
toList(): 将数组或集合转换为列表类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.6、Coroutine 相关的扩展函数：

launch(): 用于启动一个新的协程。
async(): 用于在协程中异步执行一个任务，并返回一个 Deferred 对象，该对象包含任务执行的结果。
withContext(): 用于切换协程的上下文，可以指定协程运行的线程池、任务调度器等。
delay(): 用于暂停协程的执行，类似于 Thread.sleep()。
runBlocking(): 用于在主线程中阻塞执行一个协程，常用于测试协程相关代码。
SupervisorJob(): 用于创建一个带有 Supervisor 机制的协程作业。
CoroutineExceptionHandler(): 用于捕获协程中的异常并进行处理。
asFlow(): 用于将集合、数组等数据结构转换为 Kotlin Flow，方便进行异步流式处理。
buffer(): 用于缓存协程执行的结果，避免过多的线程切换和资源占用。
launchWhenCreated(): 用于在 Android 中在 onCreate() 方法中启动协程，避免内存泄漏。

withTimeout(): 用于设置协程的执行超时时间，超过指定时间将抛出 TimeoutCancellationException 异常。
withTimeoutOrNull(): 与 withTimeout() 类似，不同的是当超时时会返回 null 而不是抛出异常。
flowOn(): 用于将上游流的处理转移到指定的调度器上，从而避免 UI 线程的阻塞。
collectLatest(): 用于取消前一个收集器并创建一个新的收集器，以确保只处理最新的数据。
conflate(): 用于去除流中的重复数据，只保留最新的数据。
combine(): 用于将多个流合并为一个流，并在每个流更新时触发新的操作。
retry(): 用于在协程中处理失败的异步任务，并进行重试，可以设置重试的次数、延迟时间等参数。
select(): 用于从多个流中选择一个可用的流并执行操作，类似于 switch case。
Mutex.withLock(): 用于在协程中执行互斥锁操作，避免多个协程同时修改同一个资源的问题。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.7、IO 相关的扩展函数：

File.readBytes(): 用于读取文件的所有字节并返回一个 ByteArray。
File.readText(): 用于读取文件的所有文本内容并返回一个 String。
File.writeBytes(): 用于将 ByteArray 写入到指定的文件中。
File.writeText(): 用于将指定的文本内容写入到指定的文件中。
InputStream.readBytes(): 用于读取输入流中的所有字节并返回一个 ByteArray。
InputStream.readText(): 用于读取输入流中的所有文本内容并返回一个 String。
OutputStream.writeBytes(): 用于将指定的 ByteArray 写入到输出流中。
OutputStream.writeText(): 用于将指定的文本内容写入到输出流中。
URL.readText(): 用于从指定的 URL 中读取所有文本内容并返回一个 String。


File.copyTo(): 用于将一个文件复制到另一个文件或目录中。
File.deleteRecursively(): 用于递归地删除一个目录及其子目录和文件。
File.list(): 用于获取一个目录中的所有文件和子目录的名称，并返回一个数组。
File.walk(): 用于递归地遍历一个目录及其子目录，并返回一个包含所有文件和子目录的 File 对象的序列。
InputStream.copyTo(): 用于将输入流的所有字节复制到指定的输出流中。
OutputStream.buffered(): 用于将输出流包装在缓冲区中，以提高写入性能。
Reader.readLines(): 用于从读取器中读取所有行，并返回一个包含每行文本的 List。
Writer.buffered(): 用于将输出流包装在缓冲区中，以提高写入性能。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.8、反射相关的扩展函数：

KClass<*>.createInstance(): 创建一个类的实例。
KClass<*>.memberProperties: 获取一个类的所有成员属性。
KClass<*>.memberFunctions: 获取一个类的所有成员函数。
KClass<*>.primaryConstructor: 获取一个类的主构造函数。
KClass<*>.constructors: 获取一个类的所有构造函数。
Any?.javaClass.kotlin: 获取一个对象的运行时类型。
KClass<*>.isSubclassOf: 判断一个类是否是另一个类的子类。
KClass<*>.isSuperclassOf: 判断一个类是否是另一个类的父类。
KClass<*>.findAnnotation: 查找一个类上的指定注解。
KFunction<*>.callBy: 以指定的参数调用一个函数。
KProperty<*>.get: 获取一个属性的值。
KMutableProperty<*>.set: 设置一个属性的值。
1
2
3
4
5
6
7
8
9
10
11
12
13

3.9、时间相关的扩展函数：

plus：为日期或时间添加指定的时间量，例如 plusDays，plusHours 等。
minus：从日期或时间中减去指定的时间量，例如 minusDays，minusHours 等。
toInstant：将日期转换为 Instant 对象。
toLocalDate：将日期转换为 LocalDate 对象。
toLocalDateTime：将日期转换为 LocalDateTime 对象。
toLocalTime：将日期转换为 LocalTime 对象。
with：返回修改了指定字段的日期对象。
withDayOfMonth：将日期设置为指定月份的某一天。
withDayOfYear：将日期设置为指定年份的某一天。
withMonth：将日期设置为指定月份。
withYear：将日期设置为指定年份。
format：将日期格式化为字符串。
parse：将字符串解析为日期。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.10、UI 相关的扩展函数：

Kotlin标准库中并没有提供特定的UI相关扩展函数，但可以通过使用Kotlin Android Extensions或Jetpack Compose等第三方库来方便地操作UI组件。Kotlin Android Extensions提供了一个布局容器中每个视图的扩展属性，这样您就可以直接通过名称引用视图，而不需要使用findViewById()函数。Jetpack Compose则提供了一个完全声明式的UI编程模型，使得开发者可以使用Kotlin DSL构建UI。

以下是一些Kotlin Android Extensions中的示例扩展属性：

findViewById<T>(id: Int): T：
根据给定的ID查找视图，并返回指定类型的视图对象。
viewModels(): ViewModelProvider.Factory：
用于从ViewModelProvider中获取与当前Fragment或Activity关联的ViewModel。
navArgs(): Lazy<Args>：
用于获取与当前Fragment关联的导航参数。


以下是Jetpack Compose中的示例函数：

Text(text: String, modifier: Modifier = Modifier): 显示文本的Composable函数。

Button(onClick: () -> Unit, modifier: Modifier = Modifier, enabled: Boolean = true, interactionSource: MutableInteractionSource = remember { MutableInteractionSource() }, elevation: ButtonElevation? = null, contentPadding: PaddingValues = ButtonDefaults.ContentPadding, shape: Shape = MaterialTheme.shapes.small, border: BorderStroke? = null, colors: ButtonColors = ButtonDefaults.buttonColors()): 按钮的Composable函数。

Row(modifier: Modifier = Modifier, horizontalArrangement: Arrangement.Horizontal = Arrangement.Start, verticalAlignment: Alignment.Vertical = Alignment.Top, content: @Composable RowScope.() -> Unit): 显示一行视图的Composable函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.11、作用域函数类型的扩展函数

作用域函数（Scope Functions）是 Kotlin 的一种特殊的扩展函数，用于在特定的作用域中执行一些操作，例如创建对象、调用方法、处理空值等。作用域函数包括以下几种：

3.1.1、let

let()：在对象上下文中执行给定的代码块，返回代码块的执行结果。用于安全调用可空对象。

val nullableString: String? = "Hello"
nullableString?.let { 
    // 对可空字符串进行安全调用，避免 NPE
    println(it) // 输出 "Hello"
}
1
2
3
4
5

3.1.2、run

如果需要在对象上执行一些操作并返回结果，可以使用 run

fun <T, R> T.run(block: T.() -> R): R
1

T 代表对象的类型，R 代表返回值的类型，block 是一个 lambda 函数，它不接受任何参数并返回一个结果

run()：在对象上下文中执行给定的代码块，返回代码块的执行结果。与 let() 类似，但它将调用对象本身作为代码块的参数。

val str = "Hello"
val result = str.run {
    // 在字符串上下文中执行代码块
    this.length // 返回字符串的长度
}
println(result) // 输出 5
1
2
3
4
5
6

3.1.3、with

with()：在对象上下文中执行给定的代码块，返回代码块的执行结果。与 let() 和 run() 不同，它是一个普通函数而不是扩展函数，需要传递对象作为第一个参数。

val list = listOf("Apple", "Banana", "Cherry")
val result = with(list) {
    // 在列表上下文中执行代码块
    size // 返回列表的大小
}
println(result) // 输出 3
1
2
3
4
5
6

3.1.4、apply

使用 apply 可以简化对对象的初始化和设置，同时提高代码的可读性和可维护性。

fun <T> T.apply(block: T.() -> Unit): T
1

T 代表对象的类型，block 是一个 lambda 函数，它不接受参数并且不返回任何值。在 block 中，你可以访问和修改对象的属性和方法

apply()：在对象上下文中执行给定的代码块，返回对象本身。与 run() 类似，但它返回对象本身而不是代码块的执行结果。

val person = Person()
person.apply {
    // 在 Person 对象上下文中执行代码块
    name = "Tom"
    age = 30
}.sayHello() // 对 person 对象调用 sayHello() 方法

1
2
3
4
5
6
7

3.1.5、also

also 函数返回的是原始对象本身，通常用于在不修改原始对象的情况下，执行一些额外的操作或打印日志。

also()：在对象上下文中执行给定的代码块，返回对象本身。与 let() 类似，但它返回对象本身而不是代码块的执行结果。

val str = "Hello"
val result = str.also {
    // 在字符串上下文中执行代码块
    println(it) // 输出 "Hello"
}
println(result) // 输出 "Hello"
1
2
3
4
5
6

3.1.6、区别和联系

• let、also、run 和 apply 的返回值都是其代码块的最后一行，但 with 的返回值是传入的对象。
• let、also、run 和 with 都是单独使用的作用域函数，而 apply 则通常用于创建一个对象并在其上执行一些初始化操作。
• let 的主要作用是在代码块内对对象进行操作并返回一个结果。let 的参数可以用 it 表示，例如：someObject.let { it.property = someValue }。
• also 的主要作用是对对象进行一些非空检查操作以及在代码块内执行一些副作用操作，also 的参数可以用 it 表示，例如：someObject?.also { it.doSomething() }。
• run 的主要作用是在代码块内对对象进行操作并返回结果，run 的参数可以用 this 或者省略不写，例如：someObject.run { this.property } 或者 someObject.run { property }。
• with 的主要作用是对一个对象进行一系列操作，with 的第一个参数是需要进行操作的对象，第二个参数是需要执行的代码块，例如：with(someObject) { property = someValue }。
• apply 的主要作用是在代码块内对对象进行一系列初始化操作，并返回对象本身，apply 的参数可以用 this 或者省略不写，例如：someObject.apply { this.property = someValue } 或者 someObject.apply { property = someValue }。

综上所述，这些作用域函数有不同的用途和特点，需要根据具体的场景和需求选择使用。

为什么说apply的返回值是其代码的最后一行

在 Kotlin 中，apply 函数是一种作用域函数，其作用是将一个对象作为函数接收者，然后在函数块中对该对象进行操作，最后将该对象返回。由于该函数的返回值就是该对象本身，因此如果在函数块中最后一行没有显式指定返回值，则默认返回该对象。

举个例子，假设我们有一个 Person 类：

class Person(var name: String, var age: Int)
1

我们可以使用 apply 函数来创建一个新的 Person 对象并进行初始化：

val person = Person("John", 30).apply {
    name = "Jane"
    age += 5
}
1
2
3
4

在上面的代码中，apply 函数的返回值就是新创建的 Person 对象，因此我们可以在同一行继续对其进行操作。

Regenerate