原文： http://zetcode.com/kotlin/sets/

Kotlin 集教程展示了如何在 Kotlin 中使用集。 集是元素的一般无序集，不允许重复。

Kotlin 区分只读集和可变集。 用setOf()创建只读集，用mutableSetOf()设置可变集。

Kotlin setOf()

setOf()方法在 Kotlin 中创建一个新的只读集。

KotlinSetOf.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val words = setOf("pen", "cup", "dog", "spectacles")
  6.     println("The set contains ${words.size} elements.")
  7. }

该示例使用setOf()创建一组新单词。 集的大小由size属性确定。

集不能包含重复的元素。

KotlinSetNoDuplicates.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val words2 = setOf("pen", "cup", "dog", "pen", "spectacles")
  6.     words2.forEach { e -> println(e)}
  7. }

即使我们在setOf()中添加了两支笔，也只有一支笔。

  1. pen
  2. cup
  3. dog
  4. spectacles

这是输出。

Kotlin 集基础知识

在下一个示例中，我们有一个简单的 Kotlin Set示例。

KotlinSetBasic.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2)
  7.     val len = nums.count()
  8.     val max = nums.max()
  9.     val min = nums.min()
  10.     val sum = nums.sum()
  11.     val avg = nums.average()
  13.     val msg = """
  14.                max: $max, min: $min,
  15.                count: $len, sum: $sum,
  16.                average: $avg
  17.               """
  18.     println(msg.trimIndent())
  19. }

该示例创建了一组数字并计算了一些统计信息。

  1. val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2)

使用setOf()函数创建 Kotlin 只读集。

  1. val len = nums.count()
  2. val max = nums.max()
  3. val min = nums.min()
  4. val sum = nums.sum()
  5. val avg = nums.average()

我们计算值的数量，最大值，最小值，总和和平均值。

  1. max: 11, min: 1,
  2. count: 8, sum: 45,
  3. average: 5.625

这是输出。

Kotlin 集索引

集中的每个元素都有一个索引。 Kotlin 集索引从零开始。 最后一个元素的索引为len-1。

KotlinSetIndex.kt

  1. package com.zetcode
  3. fun main(args: Array<String&t;) {
  5.     val words = setOf("pen", "cup", "dog", "person",
  6.             "cement", "coal", "spectacles", "cup", "bread")
  8.     val w1 = words.elementAt(0)
  9.     println(w1)
  11.     val i1 = words.indexOf("cup")
  12.     println("The first index of cup is $i1")
  14.     val i2 = words.lastIndexOf("cup")
  15.     println("The last index of cup is $i2")
  16. }

该示例介绍了 Kotlin Set索引操作。

  1. val w1 = words.elementAt(0)

使用elementAt()方法检索元素。 该方法将要检索的元素的索引作为参数。

  1. val i1 = words.indexOf("cup")

indexOf()返回单词在集中首次出现的索引。

  1. val i2 = words.lastIndexOf("cup")

lastIndexOf()返回该单词在集中最后一次出现的索引。

  1. pen
  2. The first index of cup is 1
  3. The last index of cup is 1

这是输出。

Kotlin 集大小

count()方法返回集中的元素数。

KotlinSetCount.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12)
  7.     val len = nums.count()
  8.     println("There are $len elements")
  10.     val size = nums.size
  11.     println("The size of the set is $size")
  13.     val n1 = nums.count { e -> e < 0 }
  14.     println("There are $n1 negative values")
  16.     val n2 = nums.count { e -> e % 2 == 0 }
  17.     println("There are $n2 even values")
  18. }

该示例返回集中值的数量，负值的数量和偶数的数量。

  1. val len = nums.count()
  2. println("There are $len elements")
  4. val size = nums.size
  5. println("The size of the set is $size")

我们可以使用count()方法或size属性来确定集中元素的数量。

  1. val n1 = nums.count { e -> e < 0 }

count()可以将谓词函数作为参数。 在我们的情况下，它对于小于 0 的值返回true。

  1. val n2 = nums.count { e -> e % 2 == 0 }

我们得到集中偶数的数量。

  1. There are 11 elements
  2. The size of the set is 11
  3. There are 3 negative values
  4. There are 5 even values

这是输出。

Kotlin 集第一个和最后一个元素

我们有方法来获取集的第一个和最后一个元素。

KotlinSetFirstLast.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val words = setOf("pen", "cup", "dog", "person",
  6.             "cement", "coal", "donkey", "spectacles")
  8.     val w1 = words.first()
  9.     println(w1)
  11.     val w2 = words.last()
  12.     println(w2)
  14.     val w3 = words.findLast { w -> w.startsWith('d') }
  15.     println(w3)
  17.     val w4 = words.first { w -> w.startsWith('d') }
  18.     println(w4)
  19. }

该示例创建了一组单词。 我们得到集的第一个和最后一个元素。

  1. val w1 = words.first()

我们用first()获得第一个元素。

  1. val w2 = words.last()

我们用last()获得最后一个元素。

  1. val w3 = words.findLast { w -> w.startsWith('d') }

我们以findLast()检索以’d’开头的集的最后一个元素。

  1. val w4 = words.first { w -> w.startsWith('d') }

我们以first()检索以’d’开头的集的第一个元素。

  1. pen
  2. spectacles
  3. donkey
  4. dog

这是输出。

Kotlin 集迭代

Set迭代或Set循环是一个遍历集元素的过程。

KotlinSetIterate.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val words = setOf("pen", "cup", "dog", "person",
  6.             "cement", "coal", "spectacles")
  8.     words.forEach { e -> print("$e ") }
  9.     println()
  11.     for (word in words) {
  13.         print("$word ")
  14.     }
  16.     println()
  18.     for (i in 0 until words.size) {
  20.         print("${words.elementAt(i)} ")
  21.     }
  23.     println()
  25.     words.forEachIndexed({i, e -> println("$i - $e")})
  27.     val it: Iterator<String> = words.asIterable().iterator()
  29.     while (it.hasNext()) {
  31.         val e = it.next()
  32.         print("$e ")
  33.     }
  35.     println()
  36. }

该示例显示了在 Kotlin 中循环播放集的五种方法。

  1. words.forEach { e -> print("$e ") }

forEach()对每个设置的元素执行给定的动作。 我们为它传递了一个匿名函数，该函数将打印当前元素。

  1. for (word in words) {
  3.     print("$word ")
  4. }

我们用for循环设置。 for循环逐个遍历设置的元素； 在每个循环中，word变量指向集中的下一个元素。

  1. for (i in 0 until words.size) {
  3.     print("${words.elementAt(i)} ")
  4. }

另一种for循环利用集的大小。 until关键字创建一系列设置的索引。

  1. words.forEachIndexed({i, e -> println("$i - $e")})

使用forEachIndexed()方法，我们遍历具有每次迭代可用索引和值的集。

  1. val it: Iterator<String> = words.asIterable().iterator()
  3. while (it.hasNext()) {
  5.     val e = it.next()
  6.     print("$e ")
  7. }

最后一种方法是使用Iterator和while循环。

  1. pen cup dog person cement coal spectacles 
  2. pen cup dog person cement coal spectacles 
  3. pen cup dog person cement coal spectacles 
  4. 0 - pen
  5. 1 - cup
  6. 2 - dog
  7. 3 - person
  8. 4 - cement
  9. 5 - coal
  10. 6 - spectacles
  11. pen cup dog person cement coal spectacles

这是输出。

Kotlin 集排序

以下示例显示如何在 Kotlin 中对Set值进行排序。 由于使用setOf()创建的集是只读的，因此这些方法不会更改集，而是返回新的修改后的列表。

Car.kt

  1. package com.zetcode.bean
  3. data class Car(var name: String, var price: Int)

这是一个Car bean。

KotlinSetSorting.kt

  1. package com.zetcode
  3. import com.zetcode.bean.Car
  5. fun main(args: Array<String>) {
  7.     val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2)
  9.     val sortAsc = nums.sorted()
  10.     println(sortAsc)
  12.     val sortDesc = nums.sortedDescending()
  13.     println(sortDesc)
  15.     val revNums = nums.reversed()
  16.     println(revNums)
  18.     val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
  19.             Car("Skoda", 5670), Car("Mercedes", 18600))
  21.     val res = cars.sortedBy { car -> car.name }
  22.     res.forEach { e -> println(e) }
  24.     println("*************")
  26.     val res2 = cars.sortedByDescending { car -> car.name }
  27.     res2.forEach { e -> println(e) }
  28. }

该示例按升序和降序对集值进行排序，反转集元素，并按名称对汽车对象进行排序。

  1. val sortAsc = nums.sorted()

sorted()方法返回根据自然排序顺序排序的所有元素的列表。

  1. val sortDesc = nums.sortedDescending()

sortedDescending()方法返回所有元素按照其自然排序顺序降序排列的列表。

  1. val revNums = nums.reversed()

reversed()方法返回具有相反顺序元素的列表。

  1. val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
  2.         Car("Skoda", 5670), Car("Mercedes", 18600))

我们创建了一组汽车对象。 这些对象可以按名称或价格排序。

  1. val res = cars.sortedBy { car -> car.name }

使用sortedBy()，我们按名称对汽车进行升序排序。

  1. val res2 = cars.sortedByDescending { car -> car.name }

使用sortedByDescending()，我们按名称对汽车进行降序排序。

  1. [1, 2, 3, 5, 6, 8, 9, 11]
  2. [11, 9, 8, 6, 5, 3, 2, 1]
  3. [2, 6, 9, 1, 8, 3, 5, 11]
  4. Car(name=Mazda, price=6300)
  5. Car(name=Mercedes, price=18600)
  6. Car(name=Skoda, price=5670)
  7. Car(name=Toyota, price=12400)
  8. *************
  9. Car(name=Toyota, price=12400)
  10. Car(name=Skoda, price=5670)
  11. Car(name=Mercedes, price=18600)
  12. Car(name=Mazda, price=6300)

这是输出。

Kotlin 集包含

使用contains()方法，我们可以检查集中是否包含指定的元素。

KotlinSetContains.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12)
  7.     val r = nums.contains(4)
  9.     if (r) println("The set contains 4")
  10.     else println("The set does not contain 4")
  12.     val r2 = nums.containsAll(setOf(1, -1))
  14.     if (r2) println("The set contains -1 and 1")
  15.     else println("The set does not contain -1 and 1")
  16. }

可以检查一组是否包含一个或多个元素。

  1. val r = nums.contains(4)

在这里，我们检查nums集是否包含 4。该方法返回布尔值。

  1. val r2 = nums.containsAll(setOf(1, -1))

此行检查集是否包含两个值：1 和-1。

  1. The set contains 4
  2. The set contains -1 and 1

这是输出。

Kotlin 可变集

使用mutableSetOf()，我们可以在 Kotlin 中创建可变集。

KotlinListMutable.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = mutableSetOf(3, 4, 5)
  7.     nums.add(6)
  8.     nums.add(7)
  9.     nums.addAll(setOf(8, 9, 10))
  11.     println(nums)
  13.     nums.remove(10)
  15.     println(nums)
  17.     nums.retainAll(setOf(12, 14, 16, 18))
  19.     println(nums)
  21.     nums.clear()
  23.     if (nums.isEmpty()) println("The set is empty")
  24.     else println("The set is not epty")
  25. }

该示例创建一个可变集并介绍其几种方法。

  1. val nums = mutableSetOf(3, 4, 5)

我们创建了三个整数元素的可变集。

  1. nums.add(6)
  2. nums.add(7)
  3. nums.addAll(setOf(8, 9, 10))

add()在集的末尾添加一个新元素。 addAll()在集的末尾添加了多个元素。

  1. nums.clear()

clear()方法从集中删除所有元素。

  1. if (nums.isEmpty()) println("The set is empty")
  2. else println("The set is not epty")

使用isEmpty()方法，我们检查集是否为空。

  1. [3, 4, 5, 6, 7, 8, 9, 10]
  2. [3, 4, 5, 6, 7, 8, 9]
  3. []
  4. The set is empty

这是输出。

Kotlin 并集

联合操作返回一个集，其中包含两个集中的所有不同元素。

KotlinSetUnion.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(1, 2, 3)
  6.     val nums2 = setOf(3, 4, 5)
  8.     val nums3 = nums.union(nums2)
  10.     println(nums3)
  11. }

在示例中，我们有两组整数。 我们将集与union()方法结合在一起。

  1. [1, 2, 3, 4, 5]

这是输出。

Kotlin 集最大值

以下示例显示如何查找集的最大值。

Car.kt

  1. package com.zetcode.bean
  3. data class Car(var name: String, var price: Int)

这是一个Car bean。

KotlinSetMax.kt

  1. package com.zetcode
  3. import com.zetcode.bean.Car
  5. fun main(args: Array<String>) {
  7.     val nums = setOf(11, 5, 23, 8, 1, 9, 6, 2)
  9.     println(nums.max())
  11.     val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
  12.             Car("Skoda", 5670), Car("Mercedes", 18600))
  14.     val car = cars.maxBy { car -> car.price }
  15.     println("The max price is ${car?.price} of ${car?.name}")
  16. }

该示例查找一组整数和一组汽车对象的最大值。

  1. val nums = setOf(11, 5, 23, 8, 1, 9, 6, 2)
  3. println(nums.max())

使用max()可以轻松找到一组整数的最大值。

  1. val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
  2.         Car("Skoda", 5670), Car("Mercedes", 18600))
  4. val car = cars.maxBy { car -> car.price }
  5. println("The max price is ${car?.price} of ${car?.name}")

处理对象时，需要指定用于查找最大值的属性。 maxBy()方法具有选择器函数，用于选择汽车的price属性。

  1. 23
  2. The max price is 18600 of Mercedes

这是输出。

Kotlin 集过滤器

过滤是一种操作，只有满足某些条件的元素才能通过。

Car.kt

  1. package com.zetcode.bean
  3. data class Car(var name: String, var price: Int)

这是一个Car bean。

KotlinListFilter.kt

  1. package com.zetcode
  3. import com.zetcode.bean.Car
  5. fun main(args: Array<String>) {  
  7.     val words = setOf("pen", "cup", "dog", "person",
  8.             "cement", "coal", "spectacles")
  10.     val words2 = words.filter { e -> e.length == 3 }
  11.     words2.forEach { e -> print("$e ") }
  13.     println()
  15.     val words3 = words.filterNot { e -> e.length == 3 }
  17.     words3.forEach { e -> print("$e ") }
  19.     println()
  21.     val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
  22.             Car("Skoda", 5670), Car("Mercedes", 18600))
  24.     val res = cars.filter { car -> car.price > 10000 }
  25.     res.forEach { e -> println(e) }
  26. }

该示例介绍了对 Kotlin 集的过滤操作。

  1. val words2 = words.filter { e -> e.length == 3 }

filter()方法采用谓词函数作为参数。 谓词给出了元素必须满足的条件。 我们过滤掉长度等于 3 的单词。

  1. val words3 = words.filterNot { e -> e.length == 3 }

filterNot()的作用相反：它允许通过不符合给定条件的元素。

  1. val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
  2.         Car("Skoda", 5670), Car("Mercedes", 18600))
  4. val res = cars.filter { car -> car.price > 10000 }

这些行过滤掉价格大于 10000 的汽车对象。

  1. pen cup dog 
  2. person cement coal spectacles 
  3. Car(name=Toyota, price=12400)
  4. Car(name=Mercedes, price=18600)

这是输出。

Kotlin 集映射

映射操作通过在集的每个元素上应用转换函数来返回修改后的列表。

KotlinListMap.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(1, 2, 3, 4, 5, 6)
  7.     val nums2 = nums.map { e -> e * 2 }
  8.     println(nums2)
  9. }

我们有一组整数。 使用map()方法，我们将每个集元素乘以 2。该方法将重建一个新列表。

  1. [2, 4, 6, 8, 10, 12]

这是示例输出。

Kotlin 集归约

精简是一种终端操作，可将设置值聚合为单个值。 reduce()方法对一个累加器和每个元素（从左到右）应用一个函数，以将其减小为单个值。

KotlinSetReduce.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, 5, 3, 2, 1, 7, 6, 8, 9)
  7.     val sum = nums.reduce { total, next -> total + next }
  8.     println(sum)
  9. }

在示例中，我们对一组整数使用reduce操作。

  1. val sum = nums.reduce { total, next -> total + next }

我们计算值的总和。 total是累加器，next是列表中的下一个值。

  1. 45

这是输出。

Kotlin 集折叠

折叠操作类似于缩小操作。 折叠是将设置值聚合为单个值的终端操作。 区别在于折叠从初始值开始。

KotlinSetFold.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val expenses = setOf(20, 40, 80, 15, 25)
  7.     val cash = 550
  9.     val res = expenses.fold(cash) {total, next -> total - next}
  10.     println(res)
  11. }

我们有一套费用。 这些费用适用于初始可用现金金额。

  1. val res = expenses.fold(cash) {total, next -> total - next}

利用fold()，我们从cash推算出所有费用，并返回剩余值。

  1. 370

这是我们减去可用金额的所有费用后的余额。

Kotlin 集分块

有时候，在进行约简时，我们需要处理集中的更多元素。 我们可以使用chunked()方法将集分成列表列表。

KotlinSetChunked.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(1, 2, 3, 4, 5, 6)
  7.     val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] }
  9.     println(res)
  10. }

在示例中，我们有一组六个值。 我们要实现以下操作：1*2 + 3*4 + 5*6。 为此，我们需要将列表分成两个值的块。

  1. val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] }

我们将集拆分为两个元素的列表，然后对其进行折叠。 next是我们可以在其中使用索引操作的列表。

  1. 44

这是示例的输出。

Kotlin 集分区

分区操作将原始集拆分为成对的列表。 第一个列表包含其指定谓词产生true的元素，而第二个列表包含其谓词产生false的元素。

KotlinSetPartition.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, -5, 3, 2, -1, 7, -6, 8, 9)
  7.     val (nums2, nums3) = nums.partition { e -> e < 0 }
  9.     println(nums2)
  10.     println(nums3)
  11. }

我们有一组整数。 使用partition()方法，我们将集分为两个子列表： 一个包含负值，另一个包含正值。

  1. val (nums2, nums3) = nums.partition { e -> e < 0 }

使用解构声明，我们将集一次性分成两部分。

  1. [-5, -1, -6]
  2. [4, 3, 2, 7, 8, 9]

这是输出。

Kotlin 集分组

groupBy()方法通过给定选择器函数返回的键将原始元素集应用于每个元素。 它返回一个映射，其中每个组键都与对应元素的列表相关联。

KotlinSetGroupBy.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(1, 2, 3, 4, 5, 6, 7, 8)
  7.     val res = nums.groupBy { if (it % 2 == 0) "even" else "odd" }
  8.     println(res)
  10.     val words = setOf("as", "pen", "cup", "doll", "my", "dog", "spectacles")
  12.     val res2 = words.groupBy { it.length }
  13.     println(res2)
  14. }

该示例显示了如何使用groupBy()方法。

  1. val nums = setOf(1, 2, 3, 4, 5, 6, 7, 8)
  3. val res = nums.groupBy { if (it % 2 == 0) "even" else "odd" }
  4. println(res)

这些行创建了一个映射，该映射具有两个键："even"和"odd"。 "even"指向偶数值列表，"odd"指向奇数值列表。

  1. val words = setOf("as", "pen", "cup", "doll", "my", "dog", "spectacles")
  3. val res2 = words.groupBy { it.length }

在这里，我们创建一个带有整数键的映射。 每个关键字将具有一定长度的单词分组。

  1. {odd=[1, 3, 5, 7], even=[2, 4, 6, 8]}
  2. {2=[as, my], 3=[pen, cup, dog], 4=[doll], 10=[spectacles]}

这是输出。

集any()

如果至少一个元素与给定的谓词函数匹配，则any()方法返回true。

KotlinSetAny.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, 5, 3, 2, -1, 7, 6, 8, 9)
  7.     val r = nums.any { e -> e > 10 }
  8.     if (r) println("There is a value greater than ten")
  9.     else println("There is no value greater than ten")
  11.     val r2 = nums.any { e -> e < 0 }
  12.     if (r2) println("There is a negative value")
  13.     else println("There is no negative value")

该示例显示any()的用法。

  1. val r2 = nums.any { e -> e < 0 }

在这里，我们检查该集是否包含至少一个负值。 该方法返回一个布尔值。

集all()

如果所有元素都满足给定的谓词函数，则all()返回true。

KotlinSetAll.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, 5, 3, 2, -1, 7, 6, 8, 9)
  6.     val nums2 = setOf(-3, -4, -2, -5, -7, -8)
  8.     // testing for positive only values
  9.     val r = nums.all { e -> e > 0 }
  11.     if (r) println("nums set contains only positive values")
  12.     else println("nums set does not contain only positive values")
  14.     // testing for negative only values
  15.     val r2 = nums2.all { e -> e < 0 }
  17.     if (r2) println("nums2 set contains only negative values")
  18.     else println("nums2 set does not contain only negative values")
  19. }

该示例显示all()的用法。

  1. // testing for positive only values
  2. val r = nums.all { e -> e > 0 }

在这里，我们测试nums集是否仅包含正值。

Kotlin 集删除

通过放置操作，我们从集中排除了一些元素。

KotlinSetDrop.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12)
  7.     val nums2 = nums.drop(3)
  8.     println(nums2)
  10.     val nums3 = nums.sorted().dropWhile { e -> e < 0 }
  11.     println(nums3)
  13.     val nums4 = nums.sorted().dropLastWhile { e -> e > 0 }
  14.     println(nums4)
  15. }

该示例显示了不同放置操作的用法。

  1. val nums2 = nums.drop(3)

使用drop()方法，我们排除了前三个元素。

  1. val nums3 = nums.sorted().dropWhile { e -> e < 0 }

使用dropWhile()方法，我们排除了满足给定谓词函数的前 n 个元素。

  1. val nums4 = nums.sorted().dropLastWhile { e -> e > 0 }

使用dropLastWhile()方法，我们排除了满足给定谓词函数的最后 n 个元素。

  1. [2, 1, -1, 7, 6, -8, 9, -12]
  2. [1, 2, 3, 4, 5, 6, 7, 9]
  3. [-12, -8, -1]

这是输出。

Kotlin 集提取

提取操作是放置操作的补充。 take方法通过选择一些集元素形成一个新列表。

KotlinSetTake.kt

  1. package com.zetcode
  3. fun main(args: Array<String>) {
  5.     val nums = setOf(4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12)
  7.     val nums2 = nums.take(3)
  8.     println(nums2)
  10.     val nums3 = nums.sorted().take(3)
  11.     println(nums3)
  13.     val nums4 = nums.takeWhile { e -> e > 0 }
  14.     println(nums4)
  16.     val nums5 = nums.sortedDescending().takeWhile { e -> e > 0 }
  17.     println(nums5)
  19.     val nums6 = nums.takeIf { e -> e.contains(6) }
  20.     println(nums6)
  21. }

该示例显示了各种take方法的用法。

  1. val nums2 = nums.take(3)

take()方法创建一个具有原始集的前三个元素的新列表。

  1. val nums4 = nums.takeWhile { e -> e > 0 }

takeWhile()采用满足谓词函数的前 n 个元素。

  1. val nums6 = nums.takeIf { e -> e.contains(6) }

如果满足谓词函数中的条件，则takeIf()方法将使用集的所有元素。

  1. [4, 5, 3]
  2. [-12, -8, -1]
  3. [4, 5, 3, 2, 1]
  4. [9, 7, 6, 5, 4, 3, 2, 1]
  5. [4, 5, 3, 2, 1, -1, 7, 6, -8, 9, -12]

这是输出。

在本教程中，我们介绍了 Kotlin 集。 您可能也对相关教程感兴趣： Kotlin 列表教程， Kotlin 字符串教程， Kotlin 数组教程， Kotlin 范围教程， Kotlin 变量教程， Kotlin 控制流， Kotlin 读取文件教程和 Kotlin 写入文件教程。