数组

数组是一种数据结构，它包含固定数量的相同类型或其子类型的值。Kotlin 中最常见的数组类型是对象类型数组，由 Array 类表示。

NOTE

如果您在对象类型数组中使用基本类型，这会带来性能影响，因为您的基本类型会被装箱成对象。为避免装箱开销，请改用基本类型数组。

何时使用数组

当您有需要满足的特定低级要求时，可以在 Kotlin 中使用数组。例如，如果您的性能要求超出常规应用程序所需，或者您需要构建自定义数据结构。如果您没有这些限制，请改用集合。

与数组相比，集合具有以下优势：

• 集合可以是只读的，这为您提供了更多控制，并允许您编写意图明确的健壮代码。
• 从集合中添加或删除元素很方便。相比之下，数组的大小是固定的。从数组中添加或删除元素的唯一方法是每次都创建一个新数组，这效率非常低：

fun main() {
    var riversArray = arrayOf("Nile", "Amazon", "Yangtze")

    // Using the += assignment operation creates a new riversArray,
    // copies over the original elements and adds "Mississippi"
    riversArray += "Mississippi"
    println(riversArray.joinToString())
    // Nile, Amazon, Yangtze, Mississippi
}

• 您可以使用相等运算符 (==) 来检查集合是否结构相等。您不能将此运算符用于数组。相反，您必须使用一个特殊函数，您可以在比较数组中了解更多信息。

有关集合的更多信息，请参阅集合概述。

创建数组

要在 Kotlin 中创建数组，您可以使用：

• 函数，例如 arrayOf()、arrayOfNulls() 或 emptyArray()。
• Array 构造函数。

此示例使用 arrayOf() 函数并向其传递项值：

fun main() {
    // Creates an array with values [1, 2, 3]
    val simpleArray = arrayOf(1, 2, 3)
    println(simpleArray.joinToString())
    // 1, 2, 3
}

此示例使用 arrayOfNulls() 函数创建一个给定大小的数组，并用 null 元素填充：

fun main() {
    // Creates an array with values [null, null, null]
    val nullArray: Array<Int?> = arrayOfNulls(3)
    println(nullArray.joinToString())
    // null, null, null
}

此示例使用 emptyArray() 函数创建一个空数组：

    var exampleArray = emptyArray<String>()

NOTE

由于 Kotlin 的类型推断，您可以在赋值的左侧或右侧指定空数组的类型。

例如：

var exampleArray = emptyArray<String>()

var exampleArray: Array<String> = emptyArray()

Array 构造函数接受数组大小和一个根据索引返回数组元素值的函数：

fun main() {
    // Creates an Array<Int> that initializes with zeros [0, 0, 0]
    val initArray = Array<Int>(3) { 0 }
    println(initArray.joinToString())
    // 0, 0, 0

    // Creates an Array<String> with values ["0", "1", "4", "9", "16"]
    val asc = Array(5) { i -> (i * i).toString() }
    asc.forEach { print(it) }
    // 014916
}

NOTE

与大多数编程语言一样，Kotlin 中的索引从 0 开始。

嵌套数组

数组可以相互嵌套以创建多维数组：

fun main() {
    // Creates a two-dimensional array
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }
    println(twoDArray.contentDeepToString())
    // [[0, 0], [0, 0]]

    // Creates a three-dimensional array
    val threeDArray = Array(3) { Array(3) { Array<Int>(3) { 0 } } }
    println(threeDArray.contentDeepToString())
    // [[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
}

NOTE

嵌套数组不必是相同类型或相同大小。

访问和修改元素

数组始终是可变的。要访问和修改数组中的元素，请使用索引访问运算符[]：

fun main() {
    val simpleArray = arrayOf(1, 2, 3)
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }

    // Accesses the element and modifies it
    simpleArray[0] = 10
    twoDArray[0][0] = 2

    // Prints the modified element
    println(simpleArray[0].toString()) // 10
    println(twoDArray[0][0].toString()) // 2
}

Kotlin 中的数组是_不变的_。这意味着 Kotlin 不允许您将 Array<String> 赋值给 Array<Any>，以防止可能的运行时失败。相反，您可以使用 Array<out Any>。有关更多信息，请参阅类型投影。

使用数组

在 Kotlin 中，您可以通过将数组用于向函数传递可变数量的参数，或对数组本身执行操作来使用数组。例如，比较数组、转换其内容或将它们转换为集合。

向函数传递可变数量的参数

在 Kotlin 中，您可以通过 vararg 参数向函数传递可变数量的参数。当您事先不知道参数的数量时，这很有用，例如格式化消息或创建 SQL 查询时。

要将包含可变数量参数的数组传递给函数，请使用_展开_运算符 (*)。展开运算符将数组的每个元素作为单独的参数传递给您选择的函数：

fun main() {
    val lettersArray = arrayOf("c", "d")
    printAllStrings("a", "b", *lettersArray)
    // abcd
}

fun printAllStrings(vararg strings: String) {
    for (string in strings) {
        print(string)
    }
}

有关更多信息，请参阅可变数量的参数 (varargs)。

比较数组

要比较两个数组是否以相同顺序包含相同元素，请使用 .contentEquals() 和 .contentDeepEquals() 函数：

fun main() {
    val simpleArray = arrayOf(1, 2, 3)
    val anotherArray = arrayOf(1, 2, 3)

    // Compares contents of arrays
    println(simpleArray.contentEquals(anotherArray))
    // true

    // Using infix notation, compares contents of arrays after an element
    // is changed
    simpleArray[0] = 10
    println(simpleArray contentEquals anotherArray)
    // false
}

DANGER

不要使用相等 (==) 和不相等 (!=) 运算符来比较数组的内容。这些运算符检查赋值的变量是否指向同一个对象。

要了解有关 Kotlin 中数组为何如此行为的更多信息，请参阅我们的博客文章。

转换数组

Kotlin 有许多用于转换数组的有用函数。本文只强调了其中几个，但这并非详尽列表。有关函数的完整列表，请参阅我们的API 参考。

求和

要返回数组中所有元素的总和，请使用 .sum() 函数：

fun main() {
    val sumArray = arrayOf(1, 2, 3)

    // Sums array elements
    println(sumArray.sum())
    // 6
}

NOTE

.sum() 函数只能用于数字数据类型的数组，例如 Int。

随机洗牌

要随机打乱数组中的元素，请使用 .shuffle() 函数：

fun main() {
    val simpleArray = arrayOf(1, 2, 3)

    // Shuffles elements [3, 2, 1]
    simpleArray.shuffle()
    println(simpleArray.joinToString())

    // Shuffles elements again [2, 3, 1]
    simpleArray.shuffle()
    println(simpleArray.joinToString())
}

将数组转换为集合

如果您使用不同的 API，其中一些使用数组而另一些使用集合，那么您可以将数组转换为集合，反之亦然。

转换为 List 或 Set

要将数组转换为 List 或 Set，请使用 .toList() 和 .toSet() 函数。

fun main() {
    val simpleArray = arrayOf("a", "b", "c", "c")

    // Converts to a Set
    println(simpleArray.toSet())
    // [a, b, c]

    // Converts to a List
    println(simpleArray.toList())
    // [a, b, c, c]
}

转换为 Map

要将数组转换为 Map，请使用 .toMap() 函数。

只有Pair<K,V> 类型的数组才能转换为 Map。Pair 实例的第一个值成为键，第二个值成为值。此示例使用中缀表示法调用to函数来创建 Pair 元组：

fun main() {
    val pairArray = arrayOf("apple" to 120, "banana" to 150, "cherry" to 90, "apple" to 140)

    // Converts to a Map
    // The keys are fruits and the values are their number of calories
    // Note how keys must be unique, so the latest value of "apple"
    // overwrites the first
    println(pairArray.toMap())
    // {apple=140, banana=150, cherry=90}

}

基本类型数组

如果您将 Array 类与基本类型值一起使用，这些值将被装箱成对象。作为替代方案，您可以使用基本类型数组，它允许您在数组中存储基本类型，而不会产生装箱开销的副作用：

基本类型数组	在 Java 中的等效项
BooleanArray	boolean[]
ByteArray	byte[]
CharArray	char[]
DoubleArray	double[]
FloatArray	float[]
IntArray	int[]
LongArray	long[]
ShortArray	short[]

这些类与 Array 类没有继承关系，但它们拥有相同的功能集和属性。

此示例创建 IntArray 类的一个实例：

fun main() {
    // Creates an array of Int of size 5 with the values initialized to zero
    val exampleArray = IntArray(5)
    println(exampleArray.joinToString())
    // 0, 0, 0, 0, 0
}

NOTE

要将基本类型数组转换为对象类型数组，请使用 .toTypedArray() 函数。

要将对象类型数组转换为基本类型数组，请使用 .toBooleanArray()、.toByteArray()、.toCharArray() 等等。

接下来？

• 要了解有关我们为什么建议在大多数用例中使用集合的更多信息，请阅读我们的集合概述。
• 了解其他基本类型。
• 如果您是 Java 开发人员，请阅读我们的 Java 到 Kotlin 集合迁移指南。