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