Kotlin 集合 · ZetCode 中文系列教程

# Kotlin 集 > 原文： [http://zetcode.com/kotlin/sets/](http://zetcode.com/kotlin/sets/) Kotlin 集教程展示了如何在 Kotlin 中使用集。集是元素的一般无序集，不允许重复。 Kotlin 区分只读集和可变集。用`setOf()`创建只读集，用`mutableSetOf()`设置可变集。 ## Kotlin `setOf()` `setOf()`方法在 Kotlin 中创建一个新的只读集。 `KotlinSetOf.kt` ```kt package com.zetcode fun main(args: Array<String>) { val words = setOf("pen", "cup", "dog", "spectacles") println("The set contains ${words.size} elements.") } ``` 该示例使用`setOf()`创建一组新单词。集的大小由`size`属性确定。集不能包含重复的元素。 `KotlinSetNoDuplicates.kt` ```kt package com.zetcode fun main(args: Array<String>) { val words2 = setOf("pen", "cup", "dog", "pen", "spectacles") words2.forEach { e -> println(e)} } ``` 即使我们在`setOf()`中添加了两支笔，也只有一支笔。 ```kt pen cup dog spectacles ``` 这是输出。 ## Kotlin 集基础知识在下一个示例中，我们有一个简单的 Kotlin `Set`示例。 `KotlinSetBasic.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2) val len = nums.count() val max = nums.max() val min = nums.min() val sum = nums.sum() val avg = nums.average() val msg = """ max: $max, min: $min, count: $len, sum: $sum, average: $avg """ println(msg.trimIndent()) } ``` 该示例创建了一组数字并计算了一些统计信息。 ```kt val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2) ``` 使用`setOf()`函数创建 Kotlin 只读集。 ```kt val len = nums.count() val max = nums.max() val min = nums.min() val sum = nums.sum() val avg = nums.average() ``` 我们计算值的数量，最大值，最小值，总和和平均值。 ```kt max: 11, min: 1, count: 8, sum: 45, average: 5.625 ``` 这是输出。 ## Kotlin 集索引集中的每个元素都有一个索引。 Kotlin 集索引从零开始。最后一个元素的索引为`len-1`。 `KotlinSetIndex.kt` ```kt package com.zetcode fun main(args: Array<String&t;) { val words = setOf("pen", "cup", "dog", "person", "cement", "coal", "spectacles", "cup", "bread") val w1 = words.elementAt(0) println(w1) val i1 = words.indexOf("cup") println("The first index of cup is $i1") val i2 = words.lastIndexOf("cup") println("The last index of cup is $i2") } ``` 该示例介绍了 Kotlin `Set`索引操作。 ```kt val w1 = words.elementAt(0) ``` 使用`elementAt()`方法检索元素。该方法将要检索的元素的索引作为参数。 ```kt val i1 = words.indexOf("cup") ``` `indexOf()`返回单词在集中首次出现的索引。 ```kt val i2 = words.lastIndexOf("cup") ``` `lastIndexOf()`返回该单词在集中最后一次出现的索引。 ```kt pen The first index of cup is 1 The last index of cup is 1 ``` 这是输出。 ## Kotlin 集大小 `count()`方法返回集中的元素数。 `KotlinSetCount.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12) val len = nums.count() println("There are $len elements") val size = nums.size println("The size of the set is $size") val n1 = nums.count { e -> e < 0 } println("There are $n1 negative values") val n2 = nums.count { e -> e % 2 == 0 } println("There are $n2 even values") } ``` 该示例返回集中值的数量，负值的数量和偶数的数量。 ```kt val len = nums.count() println("There are $len elements") val size = nums.size println("The size of the set is $size") ``` 我们可以使用`count()`方法或`size`属性来确定集中元素的数量。 ```kt val n1 = nums.count { e -> e < 0 } ``` `count()`可以将谓词函数作为参数。在我们的情况下，它对于小于 0 的值返回`true`。 ```kt val n2 = nums.count { e -> e % 2 == 0 } ``` 我们得到集中偶数的数量。 ```kt There are 11 elements The size of the set is 11 There are 3 negative values There are 5 even values ``` 这是输出。 ## Kotlin 集第一个和最后一个元素我们有方法来获取集的第一个和最后一个元素。 `KotlinSetFirstLast.kt` ```kt package com.zetcode fun main(args: Array<String>) { val words = setOf("pen", "cup", "dog", "person", "cement", "coal", "donkey", "spectacles") val w1 = words.first() println(w1) val w2 = words.last() println(w2) val w3 = words.findLast { w -> w.startsWith('d') } println(w3) val w4 = words.first { w -> w.startsWith('d') } println(w4) } ``` 该示例创建了一组单词。我们得到集的第一个和最后一个元素。 ```kt val w1 = words.first() ``` 我们用`first()`获得第一个元素。 ```kt val w2 = words.last() ``` 我们用`last()`获得最后一个元素。 ```kt val w3 = words.findLast { w -> w.startsWith('d') } ``` 我们以`findLast()`检索以'd'开头的集的最后一个元素。 ```kt val w4 = words.first { w -> w.startsWith('d') } ``` 我们以`first()`检索以'd'开头的集的第一个元素。 ```kt pen spectacles donkey dog ``` 这是输出。 ## Kotlin 集迭代 `Set`迭代或`Set`循环是一个遍历集元素的过程。 `KotlinSetIterate.kt` ```kt package com.zetcode fun main(args: Array<String>) { val words = setOf("pen", "cup", "dog", "person", "cement", "coal", "spectacles") words.forEach { e -> print("$e ") } println() for (word in words) { print("$word ") } println() for (i in 0 until words.size) { print("${words.elementAt(i)} ") } println() words.forEachIndexed({i, e -> println("$i - $e")}) val it: Iterator<String> = words.asIterable().iterator() while (it.hasNext()) { val e = it.next() print("$e ") } println() } ``` 该示例显示了在 Kotlin 中循环播放集的五种方法。 ```kt words.forEach { e -> print("$e ") } ``` `forEach()`对每个设置的元素执行给定的动作。我们为它传递了一个匿名函数，该函数将打印当前元素。 ```kt for (word in words) { print("$word ") } ``` 我们用`for`循环设置。 `for`循环逐个遍历设置的元素；在每个循环中，`word`变量指向集中的下一个元素。 ```kt for (i in 0 until words.size) { print("${words.elementAt(i)} ") } ``` 另一种`for`循环利用集的大小。 `until`关键字创建一系列设置的索引。 ```kt words.forEachIndexed({i, e -> println("$i - $e")}) ``` 使用`forEachIndexed()`方法，我们遍历具有每次迭代可用索引和值的集。 ```kt val it: Iterator<String> = words.asIterable().iterator() while (it.hasNext()) { val e = it.next() print("$e ") } ``` 最后一种方法是使用`Iterator`和`while`循环。 ```kt pen cup dog person cement coal spectacles pen cup dog person cement coal spectacles pen cup dog person cement coal spectacles 0 - pen 1 - cup 2 - dog 3 - person 4 - cement 5 - coal 6 - spectacles pen cup dog person cement coal spectacles ``` 这是输出。 ## Kotlin 集排序以下示例显示如何在 Kotlin 中对`Set`值进行排序。由于使用`setOf()`创建的集是只读的，因此这些方法不会更改集，而是返回新的修改后的列表。 `Car.kt` ```kt package com.zetcode.bean data class Car(var name: String, var price: Int) ``` 这是一个`Car` bean。 `KotlinSetSorting.kt` ```kt package com.zetcode import com.zetcode.bean.Car fun main(args: Array<String>) { val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2) val sortAsc = nums.sorted() println(sortAsc) val sortDesc = nums.sortedDescending() println(sortDesc) val revNums = nums.reversed() println(revNums) val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400), Car("Skoda", 5670), Car("Mercedes", 18600)) val res = cars.sortedBy { car -> car.name } res.forEach { e -> println(e) } println("*************") val res2 = cars.sortedByDescending { car -> car.name } res2.forEach { e -> println(e) } } ``` 该示例按升序和降序对集值进行排序，反转集元素，并按名称对汽车对象进行排序。 ```kt val sortAsc = nums.sorted() ``` `sorted()`方法返回根据自然排序顺序排序的所有元素的列表。 ```kt val sortDesc = nums.sortedDescending() ``` `sortedDescending()`方法返回所有元素按照其自然排序顺序降序排列的列表。 ```kt val revNums = nums.reversed() ``` `reversed()`方法返回具有相反顺序元素的列表。 ```kt val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400), Car("Skoda", 5670), Car("Mercedes", 18600)) ``` 我们创建了一组汽车对象。这些对象可以按名称或价格排序。 ```kt val res = cars.sortedBy { car -> car.name } ``` 使用`sortedBy()`，我们按名称对汽车进行升序排序。 ```kt val res2 = cars.sortedByDescending { car -> car.name } ``` 使用`sortedByDescending()`，我们按名称对汽车进行降序排序。 ```kt [1, 2, 3, 5, 6, 8, 9, 11] [11, 9, 8, 6, 5, 3, 2, 1] [2, 6, 9, 1, 8, 3, 5, 11] Car(name=Mazda, price=6300) Car(name=Mercedes, price=18600) Car(name=Skoda, price=5670) Car(name=Toyota, price=12400) ************* Car(name=Toyota, price=12400) Car(name=Skoda, price=5670) Car(name=Mercedes, price=18600) Car(name=Mazda, price=6300) ``` 这是输出。 ## Kotlin 集包含使用`contains()`方法，我们可以检查集中是否包含指定的元素。 `KotlinSetContains.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12) val r = nums.contains(4) if (r) println("The set contains 4") else println("The set does not contain 4") val r2 = nums.containsAll(setOf(1, -1)) if (r2) println("The set contains -1 and 1") else println("The set does not contain -1 and 1") } ``` 可以检查一组是否包含一个或多个元素。 ```kt val r = nums.contains(4) ``` 在这里，我们检查`nums`集是否包含 4。该方法返回布尔值。 ```kt val r2 = nums.containsAll(setOf(1, -1)) ``` 此行检查集是否包含两个值：1 和-1。 ```kt The set contains 4 The set contains -1 and 1 ``` 这是输出。 ## Kotlin 可变集使用`mutableSetOf()`，我们可以在 Kotlin 中创建可变集。 `KotlinListMutable.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = mutableSetOf(3, 4, 5) nums.add(6) nums.add(7) nums.addAll(setOf(8, 9, 10)) println(nums) nums.remove(10) println(nums) nums.retainAll(setOf(12, 14, 16, 18)) println(nums) nums.clear() if (nums.isEmpty()) println("The set is empty") else println("The set is not epty") } ``` 该示例创建一个可变集并介绍其几种方法。 ```kt val nums = mutableSetOf(3, 4, 5) ``` 我们创建了三个整数元素的可变集。 ```kt nums.add(6) nums.add(7) nums.addAll(setOf(8, 9, 10)) ``` `add()`在集的末尾添加一个新元素。 `addAll()`在集的末尾添加了多个元素。 ```kt nums.clear() ``` `clear()`方法从集中删除所有元素。 ```kt if (nums.isEmpty()) println("The set is empty") else println("The set is not epty") ``` 使用`isEmpty()`方法，我们检查集是否为空。 ```kt [3, 4, 5, 6, 7, 8, 9, 10] [3, 4, 5, 6, 7, 8, 9] [] The set is empty ``` 这是输出。 ## Kotlin 并集联合操作返回一个集，其中包含两个集中的所有不同元素。 `KotlinSetUnion.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(1, 2, 3) val nums2 = setOf(3, 4, 5) val nums3 = nums.union(nums2) println(nums3) } ``` 在示例中，我们有两组整数。我们将集与`union()`方法结合在一起。 ```kt [1, 2, 3, 4, 5] ``` 这是输出。 ## Kotlin 集最大值以下示例显示如何查找集的最大值。 `Car.kt` ```kt package com.zetcode.bean data class Car(var name: String, var price: Int) ``` 这是一个`Car` bean。 `KotlinSetMax.kt` ```kt package com.zetcode import com.zetcode.bean.Car fun main(args: Array<String>) { val nums = setOf(11, 5, 23, 8, 1, 9, 6, 2) println(nums.max()) val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400), Car("Skoda", 5670), Car("Mercedes", 18600)) val car = cars.maxBy { car -> car.price } println("The max price is ${car?.price} of ${car?.name}") } ``` 该示例查找一组整数和一组汽车对象的最大值。 ```kt val nums = setOf(11, 5, 23, 8, 1, 9, 6, 2) println(nums.max()) ``` 使用`max()`可以轻松找到一组整数的最大值。 ```kt val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400), Car("Skoda", 5670), Car("Mercedes", 18600)) val car = cars.maxBy { car -> car.price } println("The max price is ${car?.price} of ${car?.name}") ``` 处理对象时，需要指定用于查找最大值的属性。 `maxBy()`方法具有选择器函数，用于选择汽车的`price`属性。 ```kt 23 The max price is 18600 of Mercedes ``` 这是输出。 ## Kotlin 集过滤器过滤是一种操作，只有满足某些条件的元素才能通过。 `Car.kt` ```kt package com.zetcode.bean data class Car(var name: String, var price: Int) ``` 这是一个`Car` bean。 `KotlinListFilter.kt` ```kt package com.zetcode import com.zetcode.bean.Car fun main(args: Array<String>) { val words = setOf("pen", "cup", "dog", "person", "cement", "coal", "spectacles") val words2 = words.filter { e -> e.length == 3 } words2.forEach { e -> print("$e ") } println() val words3 = words.filterNot { e -> e.length == 3 } words3.forEach { e -> print("$e ") } println() val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400), Car("Skoda", 5670), Car("Mercedes", 18600)) val res = cars.filter { car -> car.price > 10000 } res.forEach { e -> println(e) } } ``` 该示例介绍了对 Kotlin 集的过滤操作。 ```kt val words2 = words.filter { e -> e.length == 3 } ``` `filter()`方法采用谓词函数作为参数。谓词给出了元素必须满足的条件。我们过滤掉长度等于 3 的单词。 ```kt val words3 = words.filterNot { e -> e.length == 3 } ``` `filterNot()`的作用相反：它允许通过不符合给定条件的元素。 ```kt val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400), Car("Skoda", 5670), Car("Mercedes", 18600)) val res = cars.filter { car -> car.price > 10000 } ``` 这些行过滤掉价格大于 10000 的汽车对象。 ```kt pen cup dog person cement coal spectacles Car(name=Toyota, price=12400) Car(name=Mercedes, price=18600) ``` 这是输出。 ## Kotlin 集映射映射操作通过在集的每个元素上应用转换函数来返回修改后的列表。 `KotlinListMap.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(1, 2, 3, 4, 5, 6) val nums2 = nums.map { e -> e * 2 } println(nums2) } ``` 我们有一组整数。使用`map()`方法，我们将每个集元素乘以 2。该方法将重建一个新列表。 ```kt [2, 4, 6, 8, 10, 12] ``` 这是示例输出。 ## Kotlin 集归约精简是一种终端操作，可将设置值聚合为单个值。 `reduce()`方法对一个累加器和每个元素（从左到右）应用一个函数，以将其减小为单个值。 `KotlinSetReduce.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, 5, 3, 2, 1, 7, 6, 8, 9) val sum = nums.reduce { total, next -> total + next } println(sum) } ``` 在示例中，我们对一组整数使用`reduce`操作。 ```kt val sum = nums.reduce { total, next -> total + next } ``` 我们计算值的总和。 `total`是累加器，`next`是列表中的下一个值。 ```kt 45 ``` 这是输出。 ## Kotlin 集折叠折叠操作类似于缩小操作。折叠是将设置值聚合为单个值的终端操作。区别在于折叠从初始值开始。 `KotlinSetFold.kt` ```kt package com.zetcode fun main(args: Array<String>) { val expenses = setOf(20, 40, 80, 15, 25) val cash = 550 val res = expenses.fold(cash) {total, next -> total - next} println(res) } ``` 我们有一套费用。这些费用适用于初始可用现金金额。 ```kt val res = expenses.fold(cash) {total, next -> total - next} ``` 利用`fold()`，我们从`cash`推算出所有费用，并返回剩余值。 ```kt 370 ``` 这是我们减去可用金额的所有费用后的余额。 ## Kotlin 集分块有时候，在进行约简时，我们需要处理集中的更多元素。我们可以使用`chunked()`方法将集分成列表列表。 `KotlinSetChunked.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(1, 2, 3, 4, 5, 6) val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] } println(res) } ``` 在示例中，我们有一组六个值。我们要实现以下操作：`1*2 + 3*4 + 5*6`。为此，我们需要将列表分成两个值的块。 ```kt val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] } ``` 我们将集拆分为两个元素的列表，然后对其进行折叠。 `next`是我们可以在其中使用索引操作的列表。 ```kt 44 ``` 这是示例的输出。 ## Kotlin 集分区分区操作将原始集拆分为成对的列表。第一个列表包含其指定谓词产生`true`的元素，而第二个列表包含其谓词产生`false`的元素。 `KotlinSetPartition.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, -5, 3, 2, -1, 7, -6, 8, 9) val (nums2, nums3) = nums.partition { e -> e < 0 } println(nums2) println(nums3) } ``` 我们有一组整数。使用`partition()`方法，我们将集分为两个子列表：一个包含负值，另一个包含正值。 ```kt val (nums2, nums3) = nums.partition { e -> e < 0 } ``` 使用解构声明，我们将集一次性分成两部分。 ```kt [-5, -1, -6] [4, 3, 2, 7, 8, 9] ``` 这是输出。 ## Kotlin 集分组 `groupBy()`方法通过给定选择器函数返回的键将原始元素集应用于每个元素。它返回一个映射，其中每个组键都与对应元素的列表相关联。 `KotlinSetGroupBy.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(1, 2, 3, 4, 5, 6, 7, 8) val res = nums.groupBy { if (it % 2 == 0) "even" else "odd" } println(res) val words = setOf("as", "pen", "cup", "doll", "my", "dog", "spectacles") val res2 = words.groupBy { it.length } println(res2) } ``` 该示例显示了如何使用`groupBy()`方法。 ```kt val nums = setOf(1, 2, 3, 4, 5, 6, 7, 8) val res = nums.groupBy { if (it % 2 == 0) "even" else "odd" } println(res) ``` 这些行创建了一个映射，该映射具有两个键：`"even"`和`"odd"`。 `"even"`指向偶数值列表，`"odd"`指向奇数值列表。 ```kt val words = setOf("as", "pen", "cup", "doll", "my", "dog", "spectacles") val res2 = words.groupBy { it.length } ``` 在这里，我们创建一个带有整数键的映射。每个关键字将具有一定长度的单词分组。 ```kt {odd=[1, 3, 5, 7], even=[2, 4, 6, 8]} {2=[as, my], 3=[pen, cup, dog], 4=[doll], 10=[spectacles]} ``` 这是输出。 ## 集`any()` 如果至少一个元素与给定的谓词函数匹配，则`any()`方法返回`true`。 `KotlinSetAny.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, 5, 3, 2, -1, 7, 6, 8, 9) val r = nums.any { e -> e > 10 } if (r) println("There is a value greater than ten") else println("There is no value greater than ten") val r2 = nums.any { e -> e < 0 } if (r2) println("There is a negative value") else println("There is no negative value") ``` 该示例显示`any()`的用法。 ```kt val r2 = nums.any { e -> e < 0 } ``` 在这里，我们检查该集是否包含至少一个负值。该方法返回一个布尔值。 ## 集`all()` 如果所有元素都满足给定的谓词函数，则`all()`返回`true`。 `KotlinSetAll.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, 5, 3, 2, -1, 7, 6, 8, 9) val nums2 = setOf(-3, -4, -2, -5, -7, -8) // testing for positive only values val r = nums.all { e -> e > 0 } if (r) println("nums set contains only positive values") else println("nums set does not contain only positive values") // testing for negative only values val r2 = nums2.all { e -> e < 0 } if (r2) println("nums2 set contains only negative values") else println("nums2 set does not contain only negative values") } ``` 该示例显示`all()`的用法。 ```kt // testing for positive only values val r = nums.all { e -> e > 0 } ``` 在这里，我们测试`nums`集是否仅包含正值。 ## Kotlin 集删除通过放置操作，我们从集中排除了一些元素。 `KotlinSetDrop.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12) val nums2 = nums.drop(3) println(nums2) val nums3 = nums.sorted().dropWhile { e -> e < 0 } println(nums3) val nums4 = nums.sorted().dropLastWhile { e -> e > 0 } println(nums4) } ``` 该示例显示了不同放置操作的用法。 ```kt val nums2 = nums.drop(3) ``` 使用`drop()`方法，我们排除了前三个元素。 ```kt val nums3 = nums.sorted().dropWhile { e -> e < 0 } ``` 使用`dropWhile()`方法，我们排除了满足给定谓词函数的前 n 个元素。 ```kt val nums4 = nums.sorted().dropLastWhile { e -> e > 0 } ``` 使用`dropLastWhile()`方法，我们排除了满足给定谓词函数的最后 n 个元素。 ```kt [2, 1, -1, 7, 6, -8, 9, -12] [1, 2, 3, 4, 5, 6, 7, 9] [-12, -8, -1] ``` 这是输出。 ## Kotlin 集提取提取操作是放置操作的补充。 `take`方法通过选择一些集元素形成一个新列表。 `KotlinSetTake.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12) val nums2 = nums.take(3) println(nums2) val nums3 = nums.sorted().take(3) println(nums3) val nums4 = nums.takeWhile { e -> e > 0 } println(nums4) val nums5 = nums.sortedDescending().takeWhile { e -> e > 0 } println(nums5) val nums6 = nums.takeIf { e -> e.contains(6) } println(nums6) } ``` 该示例显示了各种`take`方法的用法。 ```kt val nums2 = nums.take(3) ``` `take()`方法创建一个具有原始集的前三个元素的新列表。 ```kt val nums4 = nums.takeWhile { e -> e > 0 } ``` `takeWhile()`采用满足谓词函数的前 n 个元素。 ```kt val nums6 = nums.takeIf { e -> e.contains(6) } ``` 如果满足谓词函数中的条件，则`takeIf()`方法将使用集的所有元素。 ```kt [4, 5, 3] [-12, -8, -1] [4, 5, 3, 2, 1] [9, 7, 6, 5, 4, 3, 2, 1] [4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12] ``` 这是输出。在本教程中，我们介绍了 Kotlin 集。您可能也对相关教程感兴趣： [Kotlin 列表教程](/kotlin/lists/)， [Kotlin 字符串教程](/kotlin/strings/)， [Kotlin 数组教程](/kotlin/arrays/)， [Kotlin 范围教程](/kotlin/ranges/)， [Kotlin 变量教程](/kotlin/variables/)， [Kotlin 控制流](/kotlin/controlflow/)， [Kotlin 读取文件教程](/kotlin/readfile/)和 [Kotlin 写入文件教程](/kotlin/writefile/)。