Kotlin 基本数据类型（五）：Array

在 Kotlin 中使用 Array 类，来表示数组结构。数组就是一组有固定数量，类型相同或者子类型的数据结构。

什么时候使用arrays

一般情况下，在 Kotlin 中只有需要特定的底层需求的时候，开发者才需要使用数组类型。比如，有性能需求、需要自定义数据结构。如果没有这些特定的需求，使用 collections 更好。

和数组相比，集合有以下好处：

集合可以做到只读，这样开发者可以对代码有更多的控制权，并且可以写出更加健壮的代码。
在集合中添加和删除元素更加容易。而数组大小是固定的，所以每次添加和删除元素都会新建一个数组，这种方式比较低效。

kotlin 复制代码

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

开发者可以使用 (==) 操作符，来检查集合的结构是否相等。但是不能用来比较数组。数组的结构性比较就需要用到特殊的比较函数了。

创建数组

开发者可以使用以下办法来创建数组：

函数，比如 arrayOf()、arrayOfNulls() 、emptyArray()
数组构造方法

arrayOf()函数的用法如下：

kotlin 复制代码

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

arrayOfNulls()的用法如下：

kotlin 复制代码

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

emptyArray()的用法如下 :

kotlin 复制代码

var exampleArray = emptyArray<String>()

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

kotlin 复制代码

// 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

嵌套数组

数组可以相互嵌套，这样的话就可以创建多维数组：

kotlin 复制代码

// 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]]]

访问和修改元素

数组是不可变的. 可以使用范文操作符 []，来访问和修改元素：

kotlin 复制代码

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 中，开发者不允许将 Array<String> 赋值给 Array<Any>。

数组的作用

在 Kotlin 中，开发者可以将数组传递给函数作为可变参数，也可以调用数组的转换方法。比如：数组比较、元素变换、转为集合。

作为可变参数传递给函数

在 Kotlin 中，开发者可以通过 vararg 参数向函数传递可变参数。这在预先不知道参数数量的情况下非常有用，比如在格式化消息或创建 SQL 查询时。

开发者可以使用展开运算符（*），来讲一个数组作为可变参数传递给函数。展开运算符会将数组的每个元素作为单独的参数传递给函数。

kotlin 复制代码

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

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

数组比较

可以使用 contentEquals() 和 contentDeepEquals() 函数，来比较数组是否顺序相同、元素相同:

kotlin 复制代码

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

数组变换

Kotlin 有很多数组变换方法。下面重点介绍几个：

Sum

使用 sum() 函数来对数组的元素进行求和：

kotlin 复制代码

val sumArray = arrayOf(1, 2, 3)

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

Shuffle

使用 shuffle() 函数来随机的打乱数组元素的顺序：

kotlin 复制代码

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又想要用集合的API，那么开发者就可以将数组转为集合，或者集合转为数组。

数组转为 List 或者 Set

使用 toList() 和 toSet() 方法，来将数组转为 List 或者 Set：

kotlin 复制代码

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

使用 toMap() 方法，将数组转为 Map。

只不过，只有元素是 Pair<K,V> 的情况下，才可以转。Pair 的第一个值是 key，第二个值是 value。下面的例子使用中缀表示法to 来创建 Pair:

kotlin 复制代码

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，那么就会出现装箱。作为可选优化方案，开发者可以使用原始类型的数组，这样就会省去装箱的开销：

Primitive-type array	Equivalent in Java
`BooleanArray`	`boolean[]`
`ByteArray`	`byte[]`
`CharArray`	`char[]`
`DoubleArray`	`double[]`
`FloatArray`	`float[]`
`IntArray`	`int[]`
`LongArray`	`long[]`
`ShortArray`	`short[]`

这些类与 Array 类没有继承关系，但拥有相同的函数和属性。

下面是 IntArray 类的案例：

kotlin 复制代码

// 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

原文出处