Kotlin 列表 · ZetCode 中文系列教程

# Kotlin 列表 > 原文： [http://zetcode.com/kotlin/lists/](http://zetcode.com/kotlin/lists/) Kotlin 列表教程顯示了如何在 Kotlin 中使用列表。列表是元素的一般有序集合。 Kotlin 區分只讀列表和可變列表。用`listOf()`創建只讀列表，用`mutableListOf()`創建可變列表。 ## Kotlin `listOf()` `listOf()`方法在 Kotlin 中創建一個新的只讀列表。 `KotlinListOf.kt` ```kt package com.zetcode fun main() { val words = listOf("pen", "cup", "dog", "spectacles") println("The list contains ${words.size} elements.") } ``` 該示例使用`listOf()`創建新的單詞列表。列表的大小由`size`屬性確定。 ## Kotlin `List`基礎在下一個示例中，我們有一個簡單的 Kotlin `List`示例。 `KotlinListBasic.kt` ```kt package com.zetcode fun main() { val nums = listOf(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 = listOf(11, 5, 3, 8, 1, 9, 6, 2) ``` 使用`listOf()`函數創建 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`。 `KotlinListIndex.kt` ```kt package com.zetcode fun main() { val words = listOf("pen", "cup", "dog", "person", "cement", "coal", "spectacles", "cup", "bread") val w1 = words.get(0) println(w1) val w2 = words[0] println(w2) 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") val i3 = words.lastIndex println("The last index of the list is $i3") } ``` 該示例介紹了 Kotlin `List`索引操作。 ```kt val w1 = words.get(0) ``` 使用`get()`方法檢索元素。該方法將要檢索的元素的索引作為參數。 ```kt val w2 = words[0] ``` 我們還可以使用經典的 C 索引操作。 ```kt val i1 = words.indexOf("cup") ``` `indexOf()`返回列表中單詞首次出現的索引。 ```kt val i2 = words.lastIndexOf("cup") ``` `lastIndexOf()`返回列表中單詞最后一次出現的索引。 ```kt val i3 = words.lastIndex ``` `lastIndex`屬性返回列表中最后一項的索引；如果列表為空，則返回-1 ```kt pen pen The first index of cup is 1 The last index of cup is 7 The last index of the list is 8 ``` 這是輸出。 ## Kotlin 列表計數 `count()`方法返回列表中的元素數。 `KotlinListCount.kt` ```kt package com.zetcode fun main() { val nums = listOf(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 list 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 list 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 list is 11 There are 3 negative values There are 5 even values ``` 這是輸出。 ## Kotlin 列表第一個和最后一個元素我們有方法來獲取列表的第一個和最后一個元素。 `KotlinListFirstLast.kt` ```kt package com.zetcode fun main() { val words = listOf("pen", "cup", "dog", "person", "cement", "coal", "spectacles") val w1 = words.first() println(w1) val w2 = words.last() println(w2) val w3 = words.findLast { w -> w.startsWith('c') } println(w3) val w4 = words.first { w -> w.startsWith('c') } println(w4) } ``` 該示例創建一個單詞列表。我們得到列表的第一個和最后一個元素。 ```kt val w1 = words.first() ``` 我們用`first()`獲得第一個元素。 ```kt val w2 = words.last() ``` 我們用`last()`獲得最后一個元素。 ```kt val w3 = words.findLast { w -> w.startsWith('c') } ``` 我們以`findLast()`檢索以'c'開頭的列表的最后一個元素。 ```kt val w4 = words.first { w -> w.startsWith('c') } ``` 我們以`first()`檢索以'c'開頭的列表的第一個元素。 ```kt pen spectacles coal cup ``` 這是輸出。 ## Kotlin 列表迭代列表迭代或列表循環是一個遍歷列表元素的過程。 `KotlinListIterate.kt` ```kt package com.zetcode fun main() { val words = listOf("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[i]} ") } println() words.forEachIndexed({i, e -> println("words[$i] = $e")}) val it: ListIterator<String> = words.listIterator() 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[i]} ") } ``` 另一種`for`循環利用列表的大小。 `until`關鍵字創建一系列列表索引。 ```kt words.forEachIndexed({i, e -> println("words[$i] = $e")}) ``` 使用`forEachIndexed()`方法，我們遍歷具有每次迭代可用索引和值的列表。 ```kt val it: ListIterator<String> = words.listIterator() while (it.hasNext()) { val e = it.next() print("$e ") } ``` 最后一種方法是使用`ListIterator`和`while`循環。 ```kt pen cup dog person cement coal spectacles pen cup dog person cement coal spectacles pen cup dog person cement coal spectacles words[0] = pen words[1] = cup words[2] = dog words[3] = person words[4] = cement words[5] = coal words[6] = spectacles pen cup dog person cement coal spectacles ``` 這是輸出。 ## Kotlin 列表排序以下示例顯示如何在 Kotlin 中對列表值進行排序。由于使用`listOf()`創建的列表是只讀的，因此這些方法不會更改列表，但會返回新的修改后的列表。 `Car.kt` ```kt package com.zetcode.bean data class Car(var name: String, var price: Int) ``` 這是一個`Car` bean。 `KotlinListSorting.kt` ```kt package com.zetcode import com.zetcode.bean.Car fun main() { val nums = listOf(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 = listOf(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 = listOf(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()`方法，我們可以檢查列表是否包含指定的元素。 `KotlinListContains.kt` ```kt package com.zetcode fun main() { val nums = listOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12) val r = nums.contains(4) if (r) println("The list contains 4") else println("The list does not contain 4") val r2 = nums.containsAll(listOf(1, -1)) if (r2) println("The list contains -1 and 1") else println("The list does not contain -1 and 1") } ``` 可以檢查列表是否包含一個或多個元素。 ```kt val r = nums.contains(4) ``` 在這里，我們檢查`nums`列表是否包含 4。該方法返回布爾值。 ```kt val r2 = nums.containsAll(listOf(1, -1)) ``` 此行檢查列表是否包含兩個值：1 和 -1。 ```kt The list contains 4 The list contains -1 and 1 ``` 這是輸出。 ## Kotlin 可變列表使用`mutableListOf()`，我們可以在 Kotlin 中創建可變列表。我們可以在可變列表中添加新元素，刪除元素和修改元素。 `KotlinListMutable.kt` ```kt package com.zetcode fun main() { val nums = mutableListOf(3, 4, 5) nums.add(6) nums.add(7) nums.addAll(listOf(8, 9, 10)) nums.add(0, 0) nums.add(1, 1) nums.add(2, 2) println(nums) nums.shuffle() println(nums) nums.sort() println(nums) nums.removeAt(0) nums.remove(10) println(nums) nums.replaceAll { e -> e * 2 } println(nums) nums.retainAll(listOf(12, 14, 16, 18)) println(nums) nums.fill(0) println(nums) nums.set(0, 22) println(nums[0]) nums.clear() if (nums.isEmpty()) println("The list is empty") else println("The list is not epty") } ``` 該示例創建一個可變列表并提供其幾種方法。 ```kt val nums = mutableListOf(3, 4, 5) ``` 我們創建一個包含三個整數元素的可變列表。 ```kt nums.add(6) nums.add(7) nums.addAll(listOf(8, 9, 10)) ``` `add()`在列表末尾添加一個新元素。 `addAll()`在列表的末尾添加了多個元素。 ```kt nums.shuffle() ``` `shuffle()`方法隨機重新排列列表元素。改組發生在原地；即原始列表已修改。 ```kt nums.sort() ``` 元素按其自然升序排序。 ```kt nums.removeAt(0) nums.remove(10) ``` `removeAt()`方法刪除指定索引處的元素。 `remove()`方法從列表中刪除第一次出現的指定元素。 ```kt nums.replaceAll { e -> e * 2 } ``` `replaceAll()`方法使用給定函數修改列表的所有元素。在我們的例子中，我們創建一個匿名函數，將每個元素乘以 2。 ```kt nums.retainAll(listOf(12, 14, 16, 18)) ``` `retainAll()`方法僅保留參數中指定的元素；其他被刪除。 ```kt nums.fill(0) ``` `fill()`方法將所有元素替換為給定值。 ```kt nums.set(0, 22) ``` `set()`方法用給定元素替換列表中指定位置的元素。 ```kt nums.clear() ``` `clear()`方法從列表中刪除所有元素。 ```kt if (nums.isEmpty()) println("The list is empty") else println("The list is not epty") ``` 使用`isEmpty()`方法，我們檢查列表是否為空。 ```kt [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [2, 3, 6, 1, 8, 0, 7, 5, 10, 9, 4] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [1, 2, 3, 4, 5, 6, 7, 8, 9] [2, 4, 6, 8, 10, 12, 14, 16, 18] [12, 14, 16, 18] [0, 0, 0, 0] 22 The list is empty ``` 這是輸出。 ## Kotlin 列表切片切片是列表的一部分。可以使用`slice()`方法創建切片。該方法獲取要拾取的元素的索引。 `KotlinListSlice.kt` ```kt package com.zetcode fun main() { val nums = listOf(1, 2, 3, 4, 5, 6) val nums2 = nums.slice(1..3) println(nums2) val nums3 = nums.slice(listOf(3, 4, 5)) println(nums3) } ``` 在示例中，我們創建一個整數列表。從列表中，我們產生兩個切片。 ```kt val nums2 = nums.slice(1..3) ``` 我們使用范圍運算符創建包含索引為 1、2 和 3 的元素的列表切片。所有索引都包括在內。 ```kt val nums3 = nums.slice(listOf(3, 4, 5)) ``` 在第二個示例中，我們顯式提供索引列表。 ```kt [2, 3, 4] [4, 5, 6] ``` 這是輸出。 ## Kotlin 列表上限下面的示例處理查找列表的最大值。 `Car.kt` ```kt package com.zetcode.bean data class Car(var name: String, var price: Int) ``` 這是一個`Car` bean。 `KotlinListMax.kt` ```kt package com.zetcode import com.zetcode.bean.Car fun main() { val nums = listOf(11, 5, 23, 8, 1, 9, 6, 2) println(nums.max()) val cars = listOf(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 = listOf(11, 5, 23, 8, 1, 9, 6, 2) println(nums.max()) ``` 可以使用`max()`輕松找到整數列表的最大值。 ```kt val cars = listOf(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 = listOf("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 = listOf(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 = listOf(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() { val nums = listOf(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()`方法對一個累加器和每個元素（從左到右）應用一個函數，以將其減小為單個值。 `KotlinListReduce.kt` ```kt package com.zetcode fun main() { val nums = listOf(4, 5, 3, 2, 1, 7, 6, 8, 9) val sum = nums.reduce { total, next -> total + next } println(sum) val colours = listOf("red", "green", "white", "blue", "black") val res = colours.reduceRight { next, total -> "$total-$next" } println(res) } ``` 在示例中，我們對整數和字符串列表使用`reduce`操作。 ```kt val sum = nums.reduce { total, next -> total + next } ``` 我們計算值的總和。 `total`是累加器，`next`是列表中的下一個值。 ```kt val res = colours.reduceRight { next, total -> "$total-$next" } ``` `reduceRight()`從最后一個元素開始累加值，并從右到左對每個元素和當前累加器值進行運算。 ```kt 45 black-blue-white-green-red ``` 這是輸出。 ## 列表折疊折疊操作類似于縮小操作。折疊是將列表值聚合為單個值的終端操作。區別在于折疊從初始值開始。 `KotlinListFold.kt` ```kt package com.zetcode fun main() { val expenses = listOf(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()`方法將列表分成列表列表。 `KotlinListChunked.kt` ```kt package com.zetcode fun main() { val nums = listOf(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`的元素。 `KotlinListPartition.kt` ```kt package com.zetcode fun main(args: Array<String>) { val nums = listOf(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()`方法通過將給定選擇器函數返回的鍵應用于原始列表的元素進行分組，這些鍵應用于每個元素。它返回一個映射，其中每個組鍵都與對應元素的列表相關聯。 `KotlinListGroupBy.kt` ```kt package com.zetcode fun main() { val nums = listOf(1, 2, 3, 4, 5, 6, 7, 8) val res = nums.groupBy { if (it % 2 == 0) "even" else "odd" } println(res) val words = listOf("as", "pen", "cup", "doll", "my", "dog", "spectacles") val res2 = words.groupBy { it.length } println(res2) } ``` 該示例顯示了如何使用`groupBy()`方法。 ```kt val nums = listOf(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 = listOf("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]} ``` 這是輸出。 ## Kotlin 列表`any()` 如果至少一個元素與給定的謂詞函數匹配，則`any()`方法返回`true`。 `KotlinListAny.kt` ```kt package com.zetcode fun main() { val nums = listOf(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 } ``` 在這里，我們檢查列表中是否至少包含一個負值。該方法返回一個布爾值。 ## Kotlin 列表`all()` 如果所有元素都滿足給定的謂詞函數，則`all()`返回`true`。 `KotlinListAll.kt` ```kt package com.zetcode fun main() { val nums = listOf(4, 5, 3, 2, -1, 7, 6, 8, 9) val nums2 = listOf(-3, -4, -2, -5, -7, -8) // testing for positive only values val r = nums.all { e -> e > 0 } if (r) println("nums list contains only positive values") else println("nums list does not contain only positive values") // testing for negative only values val r2 = nums2.all { e -> e < 0 } if (r2) println("nums2 list contains only negative values") else println("nums2 list does not contain only negative values") } ``` 該示例顯示`all()`的用法。 ```kt // testing for positive only values val r = nums.all { e -> e > 0 } ``` 在這里，我們測試`nums`列表是否僅包含正值。 ## Kotlin 列表刪除通過放置操作，我們從列表中排除了一些元素。 `KotlinListDrop.kt` ```kt package com.zetcode fun main() { val nums = listOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12) val nums2 = nums.drop(3) println(nums2) val nums3 = nums.dropLast(3) println(nums3) val nums4 = nums.sorted().dropWhile { e -> e < 0 } println(nums4) val nums5 = nums.sorted().dropLastWhile { e -> e > 0 } println(nums5) } ``` 該示例顯示了不同放置操作的用法。 ```kt val nums2 = nums.drop(3) ``` 使用`drop()`方法，我們排除了前三個元素。 ```kt val nums3 = nums.dropLast(3) ``` 使用`dropLast()`方法，我們排除了最后三個元素。 ```kt val nums4 = nums.sorted().dropWhile { e -> e < 0 } ``` 使用`dropWhile()`方法，我們排除了滿足給定謂詞函數的前 n 個元素。 ```kt val nums5 = nums.sorted().dropLastWhile { e -> e > 0 } ``` 使用`dropLastWhile()`方法，我們排除了滿足給定謂詞函數的最后 n 個元素。 ```kt [2, 1, -1, 7, 6, -8, 9, -12] [4, 5, 3, 2, 1, -1, 7, 6] [1, 2, 3, 4, 5, 6, 7, 9] [-12, -8, -1] ``` 這是輸出。 ## Kotlin 列表提取提取操作是放置操作的補充。通過選擇一些元素，`take`方法形成一個新列表。 `KotlinListTake.kt` ```kt package com.zetcode fun main() { val nums = listOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12) val nums2 = nums.take(3) println(nums2) val nums3 = nums.takeLast(3) println(nums3) val nums4 = nums.sorted().take(3) println(nums4) val nums5 = nums.takeWhile { e -> e > 0 } println(nums5) val nums6 = nums.sortedDescending().takeWhile { e -> e > 0 } println(nums6) val nums7 = nums.takeIf { e -> e.contains(6) } println(nums7) } ``` 該示例顯示了各種`take`方法的用法。 ```kt val nums2 = nums.take(3) ``` `take()`方法創建一個具有原始列表的前三個元素的新列表。 ```kt val nums3 = nums.takeLast(3) ``` `takeLast()`方法將最后一個元素放入新列表中。 ```kt val nums5 = nums.takeWhile { e -> e > 0 } ``` `takeWhile()`采用滿足謂詞函數的前 n 個元素。 ```kt val nums7 = nums.takeIf { e -> e.contains(6) } ``` 如果滿足謂詞函數中的條件，則`takeIf()`方法將使用列表中的所有元素。 ```kt [4, 5, 3] [-8, 9, -12] [-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/sets/)， [Kotlin 數組教程](/kotlin/arrays/)， [Kotlin 映射教程](/kotlin/maps/)或列出[所有 Kotlin 教程](/all/#kotlin)。