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 isi2")
}

该示例介绍了 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 issize")

    val n1 = nums.count { e -> e < 0 }
    println("There are n1 negative values")

    val n2 = nums.count { e -> e % 2 == 0 }
    println("There aren2 even values")
}

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

val len = nums.count()
println("There are len elements")

val size = nums.size
println("The size of the set issize") 

我们可以使用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 循环是一个遍历 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()方法，我们将每个 set 元素乘以 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)

这些行创建了一个地图，该地图具有两个键：“偶数”和“奇数”。 “偶数”指向偶数值列表，“奇数”指向奇数值列表。

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 方法通过选择一些 set 元素形成一个新列表。

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]

这是输出。