Kotlin 集
Kotlin 集教程展示了如何在 Kotlin 中使用集。 集是元素的一般无序集，不允许重复。
Kotlin 区分只读集和可变集。 用setOf()创建只读集，用mutableSetOf()设置可变集。
Kotlin setOf()
setOf()方法在 Kotlin 中创建一个新的只读集。
KotlinSetOf.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
package com.zetcode
fun main(args: Array<String>) {
val words2 = setOf("pen", "cup", "dog", "pen", "spectacles")
words2.forEach { e -> println(e)}
}
即使我们在setOf()中添加了两支笔，也只有一支笔。
pen
cup
dog
spectacles
这是输出。
Kotlin 集基础知识
在下一个示例中，我们有一个简单的 Kotlin Set示例。
KotlinSetBasic.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())
}
该示例创建了一组数字并计算了一些统计信息。
val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2)
使用setOf()函数创建 Kotlin 只读集。
val len = nums.count()
val max = nums.max()
val min = nums.min()
val sum = nums.sum()
val avg = nums.average()
我们计算值的数量，最大值，最小值，总和和平均值。
max: 11, min: 1,
count: 8, sum: 45,
average: 5.625
这是输出。
Kotlin 集索引
集中的每个元素都有一个索引。 Kotlin 集索引从零开始。 最后一个元素的索引为len-1。
KotlinSetIndex.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索引操作。
val w1 = words.elementAt(0)
使用elementAt()方法检索元素。 该方法将要检索的元素的索引作为参数。
val i1 = words.indexOf("cup")
indexOf()返回单词在集中首次出现的索引。
val i2 = words.lastIndexOf("cup")
lastIndexOf()返回该单词在集中最后一次出现的索引。
pen
The first index of cup is 1
The last index of cup is 1
这是输出。
Kotlin 集大小
count()方法返回集中的元素数。
KotlinSetCount.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")
}
该示例返回集中值的数量，负值的数量和偶数的数量。
val len = nums.count()
println("There are $len elements")
val size = nums.size
println("The size of the set is $size")
我们可以使用count()方法或size属性来确定集中元素的数量。
val n1 = nums.count { e -> e < 0 }
count()可以将谓词函数作为参数。 在我们的情况下，它对于小于 0 的值返回true。
val n2 = nums.count { e -> e % 2 == 0 }
我们得到集中偶数的数量。
There are 11 elements
The size of the set is 11
There are 3 negative values
There are 5 even values
这是输出。
Kotlin 集第一个和最后一个元素
我们有方法来获取集的第一个和最后一个元素。
KotlinSetFirstLast.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)
}
该示例创建了一组单词。 我们得到集的第一个和最后一个元素。
val w1 = words.first()
我们用first()获得第一个元素。
val w2 = words.last()
我们用last()获得最后一个元素。
val w3 = words.findLast { w -> w.startsWith('d') }
我们以findLast()检索以'd'开头的集的最后一个元素。
val w4 = words.first { w -> w.startsWith('d') }
我们以first()检索以'd'开头的集的第一个元素。
pen
spectacles
donkey
dog
这是输出。
Kotlin 集迭代
Set迭代或Set循环是一个遍历集元素的过程。
KotlinSetIterate.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 中循环播放集的五种方法。
words.forEach { e -> print("$e ") }
forEach()对每个设置的元素执行给定的动作。 我们为它传递了一个匿名函数，该函数将打印当前元素。
for (word in words) {
print("$word ")
}
我们用for循环设置。 for循环逐个遍历设置的元素； 在每个循环中，word变量指向集中的下一个元素。
for (i in 0 until words.size) {
print("${words.elementAt(i)} ")
}
另一种for循环利用集的大小。 until关键字创建一系列设置的索引。
words.forEachIndexed({i, e -> println("$i - $e")})
使用forEachIndexed()方法，我们遍历具有每次迭代可用索引和值的集。
val it: Iterator<String> = words.asIterable().iterator()
while (it.hasNext()) {
val e = it.next()
print("$e ")
}
最后一种方法是使用Iterator和while循环。
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
package com.zetcode.bean
data class Car(var name: String, var price: Int)
这是一个Car bean。
KotlinSetSorting.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) }
}
该示例按升序和降序对集值进行排序，反转集元素，并按名称对汽车对象进行排序。
val sortAsc = nums.sorted()
sorted()方法返回根据自然排序顺序排序的所有元素的列表。
val sortDesc = nums.sortedDescending()
sortedDescending()方法返回所有元素按照其自然排序顺序降序排列的列表。
val revNums = nums.reversed()
reversed()方法返回具有相反顺序元素的列表。
val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
我们创建了一组汽车对象。 这些对象可以按名称或价格排序。
val res = cars.sortedBy { car -> car.name }
使用sortedBy()，我们按名称对汽车进行升序排序。
val res2 = cars.sortedByDescending { car -> car.name }
使用sortedByDescending()，我们按名称对汽车进行降序排序。
[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
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")
}
可以检查一组是否包含一个或多个元素。
val r = nums.contains(4)
在这里，我们检查nums集是否包含 4。该方法返回布尔值。
val r2 = nums.containsAll(setOf(1, -1))
此行检查集是否包含两个值：1 和-1。
The set contains 4
The set contains -1 and 1
这是输出。
Kotlin 可变集
使用mutableSetOf()，我们可以在 Kotlin 中创建可变集。
KotlinListMutable.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")
}
该示例创建一个可变集并介绍其几种方法。
val nums = mutableSetOf(3, 4, 5)
我们创建了三个整数元素的可变集。
nums.add(6)
nums.add(7)
nums.addAll(setOf(8, 9, 10))
add()在集的末尾添加一个新元素。 addAll()在集的末尾添加了多个元素。
nums.clear()
clear()方法从集中删除所有元素。
if (nums.isEmpty()) println("The set is empty")
else println("The set is not epty")
使用isEmpty()方法，我们检查集是否为空。
[3, 4, 5, 6, 7, 8, 9, 10]
[3, 4, 5, 6, 7, 8, 9]
[]
The set is empty
这是输出。
Kotlin 并集
联合操作返回一个集，其中包含两个集中的所有不同元素。
KotlinSetUnion.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()方法结合在一起。
[1, 2, 3, 4, 5]
这是输出。
Kotlin 集最大值
以下示例显示如何查找集的最大值。
Car.kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
这是一个Car bean。
KotlinSetMax.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}")
}
该示例查找一组整数和一组汽车对象的最大值。
val nums = setOf(11, 5, 23, 8, 1, 9, 6, 2)
println(nums.max())
使用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}")
处理对象时，需要指定用于查找最大值的属性。 maxBy()方法具有选择器函数，用于选择汽车的price属性。
23
The max price is 18600 of Mercedes
这是输出。
Kotlin 集过滤器
过滤是一种操作，只有满足某些条件的元素才能通过。
Car.kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
这是一个Car bean。
KotlinListFilter.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 集的过滤操作。
val words2 = words.filter { e -> e.length == 3 }
filter()方法采用谓词函数作为参数。 谓词给出了元素必须满足的条件。 我们过滤掉长度等于 3 的单词。
val words3 = words.filterNot { e -> e.length == 3 }
filterNot()的作用相反：它允许通过不符合给定条件的元素。
val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
val res = cars.filter { car -> car.price > 10000 }
这些行过滤掉价格大于 10000 的汽车对象。
pen cup dog
person cement coal spectacles
Car(name=Toyota, price=12400)
Car(name=Mercedes, price=18600)
这是输出。
Kotlin 集映射
映射操作通过在集的每个元素上应用转换函数来返回修改后的列表。
KotlinListMap.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。该方法将重建一个新列表。
[2, 4, 6, 8, 10, 12]
这是示例输出。
Kotlin 集归约
精简是一种终端操作，可将设置值聚合为单个值。 reduce()方法对一个累加器和每个元素（从左到右）应用一个函数，以将其减小为单个值。
KotlinSetReduce.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操作。
val sum = nums.reduce { total, next -> total + next }
我们计算值的总和。 total是累加器，next是列表中的下一个值。
45
这是输出。
Kotlin 集折叠
折叠操作类似于缩小操作。 折叠是将设置值聚合为单个值的终端操作。 区别在于折叠从初始值开始。
KotlinSetFold.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)
}
我们有一套费用。 这些费用适用于初始可用现金金额。
val res = expenses.fold(cash) {total, next -> total - next}
利用fold()，我们从cash推算出所有费用，并返回剩余值。
370
这是我们减去可用金额的所有费用后的余额。
Kotlin 集分块
有时候，在进行约简时，我们需要处理集中的更多元素。 我们可以使用chunked()方法将集分成列表列表。
KotlinSetChunked.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。 为此，我们需要将列表分成两个值的块。
val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] }
我们将集拆分为两个元素的列表，然后对其进行折叠。 next是我们可以在其中使用索引操作的列表。
44
这是示例的输出。
Kotlin 集分区
分区操作将原始集拆分为成对的列表。 第一个列表包含其指定谓词产生true的元素，而第二个列表包含其谓词产生false的元素。
KotlinSetPartition.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()方法，我们将集分为两个子列表： 一个包含负值，另一个包含正值。
val (nums2, nums3) = nums.partition { e -> e < 0 }
使用解构声明，我们将集一次性分成两部分。
[-5, -1, -6]
[4, 3, 2, 7, 8, 9]
这是输出。
Kotlin 集分组
groupBy()方法通过给定选择器函数返回的键将原始元素集应用于每个元素。 它返回一个映射，其中每个组键都与对应元素的列表相关联。
KotlinSetGroupBy.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()方法。
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"指向奇数值列表。
val words = setOf("as", "pen", "cup", "doll", "my", "dog", "spectacles")
val res2 = words.groupBy { it.length }
在这里，我们创建一个带有整数键的映射。 每个关键字将具有一定长度的单词分组。
{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
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()的用法。
val r2 = nums.any { e -> e < 0 }
在这里，我们检查该集是否包含至少一个负值。 该方法返回一个布尔值。
集all()
如果所有元素都满足给定的谓词函数，则all()返回true。
KotlinSetAll.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()的用法。
// testing for positive only values
val r = nums.all { e -> e > 0 }
在这里，我们测试nums集是否仅包含正值。
Kotlin 集删除
通过放置操作，我们从集中排除了一些元素。
KotlinSetDrop.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)
}
该示例显示了不同放置操作的用法。
val nums2 = nums.drop(3)
使用drop()方法，我们排除了前三个元素。
val nums3 = nums.sorted().dropWhile { e -> e < 0 }
使用dropWhile()方法，我们排除了满足给定谓词函数的前 n 个元素。
val nums4 = nums.sorted().dropLastWhile { e -> e > 0 }
使用dropLastWhile()方法，我们排除了满足给定谓词函数的最后 n 个元素。
[2, 1, -1, 7, 6, -8, 9, -12]
[1, 2, 3, 4, 5, 6, 7, 9]
[-12, -8, -1]
这是输出。
Kotlin 集提取
提取操作是放置操作的补充。 take方法通过选择一些集元素形成一个新列表。
KotlinSetTake.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方法的用法。
val nums2 = nums.take(3)
take()方法创建一个具有原始集的前三个元素的新列表。
val nums4 = nums.takeWhile { e -> e > 0 }
takeWhile()采用满足谓词函数的前 n 个元素。
val nums6 = nums.takeIf { e -> e.contains(6) }
如果满足谓词函数中的条件，则takeIf()方法将使用集的所有元素。
[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 字符串教程， Kotlin 数组教程， Kotlin 范围教程， Kotlin 变量教程， Kotlin 控制流， Kotlin 读取文件教程和 Kotlin 写入文件教程。
