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