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/)。