ZetCode

Kotlin 数组

最后修改于 2024 年 1 月 29 日

本文展示了如何在 Kotlin 中使用数组。

数组是固定数量值的集合。数组项称为数组的元素。每个元素都可以通过索引来引用。数组是基于零的。

Kotlin 数组使用诸如 arrayOf 或 intArrayOf 之类的函数创建，或者使用诸如 IntArray 或 FloatArray 之类的类创建。

Kotlin 数组初始化

在第一个示例中，我们展示了如何在 Kotlin 中初始化数组。

Initialize.kt 
package com.zetcode

import java.util.Arrays

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5)
    println(Arrays.toString(nums))

    val nums2 = (3..12).toList().toTypedArray()
    println(Arrays.toString(nums2))

    val nums3 = IntArray(5, { i -> i * 2 + 3})
    println(Arrays.toString(nums3))
}

该示例创建了三个数组。

val nums = arrayOf(1, 2, 3, 4, 5)

使用 arrayOf 函数创建数组。

println(Arrays.toString(nums))

我们使用 Arrays' 的 toString 方法来打印数组的内容。

val nums2 = (3..12).toList().toTypedArray()

在这一行中，我们从数字范围创建一个数组。

val nums3 = IntArray(5, { i -> i * 2 + 3})

此行使用 IntArray 创建数组。它接受元素数量和一个工厂函数作为参数。

[1, 2, 3, 4, 5]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
[3, 5, 7, 9, 11]

Kotlin 数组索引

下一个示例展示了 Kotlin 中的数组索引操作。

Indexing.kt 
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5)

    println(nums[2])

    nums[0] = 11
    println(nums[0])
}

我们使用索引操作来获取和修改数组值。

println(nums[2])

我们打印索引为 2 的值，即数组中的第三个元素。数组值的索引添加在一对方括号之间。

Kotlin 数组基本操作

以下示例展示了 Kotlin 数组的一些基本操作。

BasicOperations.kt 
package com.zetcode

import java.util.Arrays

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5)
    println(nums.get(0))

    nums.set(0, 0)
    println(Arrays.toString(nums))

    val nums2 = nums.plus(1)
    println(Arrays.toString(nums2))

    val slice = nums.sliceArray(1..3)
    println(Arrays.toString(slice))

    println(nums.first())
    println(nums.last())
    println(nums.indexOf(5))
}

在示例中，我们检索和修改数组元素，创建一个切片，并获取元素的索引。

println(nums.get(0))

我们使用 get 函数获取索引为 0 的元素。

nums.set(0, 0)

set 方法将指定索引处的数组元素设置为指定值。

val nums2 = nums.plus(1)

我们向数组添加一个新元素，创建一个新数组。（请记住，数组的大小是固定的；因此，创建了一个新数组）。

val slice = nums.sliceArray(1..3)

使用 sliceArray 方法，我们从数组创建一个切片。索引都是包含的。

println(nums.first())
println(nums.last())

我们获取数组的第一个和最后一个元素。

println(nums.indexOf(5))

我们获取元素 5 第一次出现的索引。

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

Kotlin 数组聚合函数

在以下示例中，我们使用一些聚合数组函数。

Aggregates.kt 
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5)

    val avg = nums.average()
    println("The average is $avg")

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

    val sumOfValues = nums.sum()
    println("The sum of values is $sumOfValues")

    val maxValue = nums.max()
    println("The maximum is $maxValue")

    val minValue = nums.min()
    println("The minimum is $minValue")
}

该示例计算数组的平均值、总和、最大值、最小值和大小。

val avg = nums.average()

average 函数计算数组值的平均值。

val nOfValues = nums.count()

元素的数量由 count 确定。

The average is 3.0
There are 5 elements
The sum of values is 15
The maximum is 5
The minimum is 1

Kotlin 数组洗牌

shuffle 函数在原地随机重新排列数组元素。

Shuffling.kt 
package com.zetcode

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5, 6)

    println(nums.joinToString())

    nums.shuffle()
    println(nums.joinToString())

    nums.shuffle()
    println(nums.joinToString())
}

在示例中，我们对数组元素洗牌两次。joinToString 函数将数组转换为字符串。

1, 2, 3, 4, 5, 6
1, 3, 5, 6, 4, 2
3, 2, 1, 5, 4, 6

Kotlin 数组 map

map 函数返回一个列表，其中包含将给定的转换函数应用于数组的每个元素的结果。

MapFun.kt 
package com.zetcode

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5, 6)

    val res = nums.map { e -> e * 2 }
    println(res)
}

我们有一个整数列表。使用 map，我们将每个整数乘以 2。

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

Kotlin 数组 count

count 方法计算数组中的元素。

CountFun.kt 
package com.zetcode

fun main() {

    val nums = intArrayOf(2, 3, 4, 5, 6, 7)

    println("There are ${nums.count()} elements in the array")

    val nOfEvens = nums.count { it % 2 == 0 }

    println("There are $nOfEvens even values in the array")
}

该示例计算数组中值的总数和偶数的数量。

There are 6 elements in the array
There are 3 even values in the array

Kotlin 随机数组元素

在下一个示例中，我们使用随机整数初始化一个数组。

RandomInts.kt 
package com.zetcode

import kotlin.random.Random

fun main() {

    val vals = Array(10) { Random.nextInt(0, 100)}
    println(vals.joinToString())
}

创建了一个包含十个随机整数的数组。随机整数由 Random.nextInt 函数生成。

Kotlin 数组遍历

在下一个示例中，我们循环遍历 Kotlin 数组。

Traverse.kt 
package com.zetcode

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5, 6, 7)

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

    println()

    nums.forEachIndexed({i, e -> println("nums[$i] = $e")})

    for (e in nums) {
        print("$e ")
    }

    println()

    val it: Iterator<Int> = nums.iterator()

    while (it.hasNext()) {

        val e = it.next()
        print("$e ")
    }
}

该示例使用四种不同的遍历方式循环遍历数组。

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

我们使用 forEach 遍历数组。此方法对数组的每个元素应用一个操作。在我们的例子中，它会打印出来。

nums.forEachIndexed({i, e -> println("nums[$i] = $e")})

forEachIndexed 对每个元素执行给定的操作，提供带元素的顺序索引。

for (e in nums) {
    print("$e ")
}

我们在 for 循环中遍历数组。

val it: Iterator<Int> = nums.iterator()

while (it.hasNext()) {

    val e = it.next()
    print("$e ")
}

最后，我们使用迭代器和 while 循环遍历数组。

1 2 3 4 5 6 7
nums[0] = 1
nums[1] = 2
nums[2] = 3
nums[3] = 4
nums[4] = 5
nums[5] = 6
nums[6] = 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7

在 Kotlin 中对数组进行排序

我们展示了如何对 Kotlin 数组进行排序。

ArraySort.kt 
package com.zetcode

fun main() {

    val nums = arrayOf(7, 3, 3, 4, 5, 9, 1)

    val sortedNums = nums.sortedArray()
    println(Arrays.toString(sortedNums))

    val sortedNumsDesc = nums.sortedArrayDescending()
    println(Arrays.toString(sortedNumsDesc))
}

该示例使用 sortedArray 按升序对数组进行排序，使用 sortedArrayDescending 按降序排序。这些方法创建新的已排序数组。

[1, 3, 3, 4, 5, 7, 9]
[9, 7, 5, 4, 3, 3, 1]

Kotlin 二维数组

在 Kotlin 中，我们可以创建二维数组。

ArrayTwoDim.kt 
package com.zetcode

fun main() {

    val array = arrayOf(intArrayOf(1, 2),
            intArrayOf(3, 4),
            intArrayOf(5, 6, 7))

    println(Arrays.deepToString(array))
}

该示例通过将 intArrayOf 函数调用嵌套到 arrayOf 函数中来创建二维数组。

[[1, 2], [3, 4], [5, 6, 7]]

Kotlin 过滤数组

使用 filter 方法，我们可以过滤数组中的数据。

Filter.kt 
package com.zetcode

fun main() {

    val nums = arrayOf(1, -2, 3, 4, -5, 7)

    nums.filter { e -> e > 0 }.forEach { e -> print("$e ") }
}

该示例创建一个正整数和负整数的数组。filter 方法用于仅选取正值。

1 3 4 7

下一个示例过滤一个用户数组。

Filter2.kt 
package com.zetcode

data class User(val fname: String, val lname: String, val salary: Int)

fun main() {

    val users = arrayOf(

        User("John", "Doe", 1230),
        User("Lucy", "Novak", 670),
        User("Ben", "Walter", 2050),
        User("Robin", "Brown", 2300),
        User("Amy", "Doe", 1250),
        User("Joe", "Draker", 1190),
        User("Janet", "Doe", 980),
        User("Albert", "Novak", 1930)
    )

    users.filter { it.salary < 1000 }.forEach { e -> println(e) }
}

我们有一个用户数组，其中包含名字、姓氏和工资属性。

users.filter { it.salary < 1000 }.forEach { e -> println(e) }

使用 filter，我们找出所有工资低于 1000 的用户。

Kotlin 数组查找元素

我们可以使用 find 和 findLast 查找元素。

ArrayFind.kt 
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    val firstEven = nums.find { it % 2 == 0 }
    println("The first even value is: $firstEven")

    val lastEven = nums.findLast { it % 2 == 0 }
    println("The last even value is: $lastEven")
}

该示例查找数组中第一个和最后一个偶数。

The first even value is: 2
The last even value is: 8

Kotlin 数组规约

规约 是一种终端操作，它将数组值聚合成一个值。reduce 方法将一个函数应用于累加器和数组中的每个元素（从左到右），将其规约为一个值。

ArrayReduce.kt 
package com.zetcode

fun main() {

    val nums = intArrayOf(2, 3, 4, 5, 6, 7)

    val total = nums.reduce { product, next -> product * next }

    println(total)
}

我们使用 reduce 方法计算数组元素的乘积。

val total = nums.reduce { product, next -> product * next }

product 是累加器，next 是数组中的下一个值。

5040

Kotlin 数组 all

如果所有元素都与给定的谓词匹配，则 all 方法返回 true。

ArrayAll.kt 
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    val hasAllEvens = nums.all { it % 2 == 0 }

    if (hasAllEvens) {

        println("The array contains only even values")
    } else {

        println("The array contains odd values")
    }
}

该示例检查数组元素是否都是偶数。

The array contains odd values

该数组包含一些奇数值。

Kotlin 数组 any

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

ArrayAny.kt 
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    val hasEvenVals = nums.any { it % 2 == 0 }

    if (hasEvenVals) {

        println("The array contains even values")
    } else {

        println("The array does contain even values")
    }
}

该示例检查数组元素是否包含任何偶数。

The array contains even values

来源

Kotlin 数组 - 语言参考

在本文中，我们介绍了 Kotlin 数组。

作者

我的名字是 Jan Bodnar，我是一个充满激情的程序员，拥有丰富的编程经验。自 2007 年以来，我一直在撰写编程文章。迄今为止，我撰写了 1,400 多篇文章和 8 本电子书。我拥有超过十年的编程教学经验。

列出 所有 Kotlin 教程。