Kotlin 基本数据类型-数组

1、定义

数组是一种保存固定数量，相同类型值的数据结构

Kotlin 中最常见的数组类型是由 Array 类表示的对象类型数组；因为在对象类型数组中使用原生类型会造成装箱开销，尽量改用原生类型数组

2、原生类型数组

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

    // 创建一个大小为5的Int数组，其中包含初始化的值
    val exampleArray = IntArray(5)
    println(exampleArray.joinToString()) // 0, 0, 0, 0, 0

可用.toTypedArray() 函数将基元类型数组转换为对象类型数组
可用.toBooleanArray(), .toByteArray(), .toCharArray() 将对象类型数组转换为基元类型数组

3、选用原则

当需要满足特殊的底层需求时，可以在 Kotlin 中使用数组，如性能要求；否则优先使用集合

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

• 集合可以是只读的，这提供了更多的控制权而支持编写具有明确意图的健壮代码

• 集合易于增删元素；相比之下，数组大小是固定的，对数组增删元素的唯一方式是每次创建一个新数组，效率很低

• 可用相等操作符（==）来检验两个集合是否在结构上相等，不能对数组使用这个操作符

4、创建数组

• 使用内置函数的方式  arrayOf(), arrayOfNulls()) 或 emptyArray()

    // 创建数组 [1, 2, 3]
    val simpleArray = arrayOf(1, 2, 3)
    println(simpleArray.joinToString())  // 1, 2, 3

    // 创建一个给定大小的数组，填充null
    val nullArray: Array<Int?> = arrayOfNulls(3)  // [null, null, null]
    println(nullArray.joinToString())    // null, null, null

    // 创建一个空数组
    var exampleArray = emptyArray<String>()
    //类型推断，可在赋值的左侧或右侧指定空数组的类型
    var exampleArray = emptyArray<String>()
    var exampleArray: Array<String> = emptyArray()

• 使用 Array 类构造函数的方式

    // 创建一个 Array<Int> 数组，初始化元素为0
    val initArray = Array<Int>(3) { 0 } // [0, 0, 0]
    println(initArray.joinToString())   // 0, 0, 0
    
    // 创建一个 Array<String> 初始化为 ["0", "1", "4", "9", "16"]
    val asc = Array(5) { i -> (i * i).toString() }
    asc.forEach { print(it) }   // 014916
   

• 多维数组 

    // 创建一个二维数组
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }
    println(twoDArray.contentDeepToString())  // [[0, 0], [0, 0]]

    // 创建一个三维数组
    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]]]

 5、访问和修改数组元素

使用索引访问运算符[]

    val simpleArray = arrayOf(1, 2, 3)
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }
    // 修改元素值
    simpleArray[0] = 10
    twoDArray[0][0] = 2
    // 打印修改后的值
    println(simpleArray[0].toString()) // 10
    println(twoDArray[0][0].toString()) // 2

6、数组做形参的使用

使用排列运算符（*），将数组的每个元素作为单独的参数传递

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

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

7、数组的比较

使用.contentEquals() 和.contentDeepEquals() 比较两个数组是否具有相同顺序的相同元素

不要使用相等（==）和不等（！=）运算符来比较数组的内容，这些操作符检查指定的变量是否指向同一个对象

    val simpleArray = arrayOf(1, 2, 3)
    val anotherArray = arrayOf(1, 2, 3)

    // 比较数组元素
    println(simpleArray.contentEquals(anotherArray))    // true
    // 使用中缀表示法，比较元素后数组的内容
    // 修改元素值
    simpleArray[0] = 10
    println(simpleArray contentEquals anotherArray)     // false

8、数组的转换

.sum() 返回数组中所有元素的总和

    val sumArray = arrayOf(1, 2, 3)
    println(sumArray.sum())         // 6

.shuffle() 随机打乱数组中的元素

    val simpleArray = arrayOf(1, 2, 3)
    simpleArray.shuffle()
    println(simpleArray.joinToString()) // 3, 1, 2
    simpleArray.shuffle()
    println(simpleArray.joinToString()) // 1, 3, 2

 .toList() 或 .toSet() 转换为 List 或 Set

    val simpleArray = arrayOf("a", "b", "c", "c")
    // 转换为 Set
    println(simpleArray.toSet())    // [a, b, c]
    // 转换为 List
    println(simpleArray.toList())  // [a, b, c, c]

.toMap() 转换为 Map

    val pairArray = arrayOf("apple" to 120, "banana" to 150, "cherry" to 90, "apple" to 140)
    // 转换为 Map
    // keys 是 fruits， values 是 calories
    // key 必须唯一，所以后面的"apple"覆盖第一个
    println(pairArray.toMap()) // {apple=140, banana=150, cherry=90}