Kotlin 数组类型

Kotlin的数组

数组在Kotlin中使用Array类来表示，Kotlin的数组Array类中定义了get、set函数以及size（相当于java数组的length）的属性

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ……
}

和Java数组的区别 

 数组的创建方式

• 一般创建数组,直接使用arrayOf(),就可以创建一个数组

val a = arrayOf(1, 2, 3)
val b = IntArray(3, { it + 1 })
val c = arrayOf("shenzhen", "guagnzhou")
c[1] = "beijing"

println(a[0])    // 输出结果：1
println(a.contentToString())    // 输出结果：[1, 2, 3]
println(b[2])    // 输出结果：3
println("${c[0]}, ${c[1]}") // 输出结果：shenzhen, beijing

println(b[3])    // 输出结果报错：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3


// 库函数 arrayOfNulls() 可以用于创建一个指定大小的、所有元素都为空的数组。

另一个选项是用接受数组大小以及一个函数参数的 Array 构造函数，用作参数的函数能够返回给定索引的每个元素初始值：

// 创建一个 Array<String> 初始化为 ["0", "1", "4", "9", "16"]
val asc = Array(5) { i -> (i * i).toString() }
asc.forEach { println(it) }

如上所述，[] 运算符代表调用成员函数 get() 和 set()。

注意: 与 Java 不同的是，Kotlin 中数组是不协变的（invariant）。

原生类型数组

Kotlin 也有无装箱开销的专门的类来表示原生类型数组: ByteArray、 ShortArray、IntArray 等等。这些类与 Array 并没有继承关系，但是它们有同样的方法属性集。它们也都有相应的工厂方法

除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = intArrayOf(1, 2, 3)
println(x[0])  // 结果是：1

x[0] = x[1] + x[2]
println(x[0])  // 结果是：5

// 大小为 5、值为 [0, 0, 0, 0, 0] 的整型数组
val arr = IntArray(5)

// 例如：用常量初始化数组中的值
// 大小为 5、值为 [42, 42, 42, 42, 42] 的整型数组
val arr = IntArray(5) { 42 }

// 例如：使用 lambda 表达式初始化数组中的值
// 大小为 5、值为 [0, 1, 2, 3, 4] 的整型数组（值初始化为其索引值）
var arr = IntArray(5) { it * 1 }

基本类型数组:ByteArray,LongArray等这些类是基本类型数组，但是跟Array类没有继承关系，但是它们有相同的属性集。Kotlin中的数组是不能型变得，也就是说Array<Int>不能赋值给Array<Any> 

val intArr: IntArray = intArrayOf(1,2,3)
val longArr: LongArray = longArrayOf(1L,2L,3L)
val floatArr: FloatArray = floatArrayOf(1.0f,2.0f,3.0f)
val doubleArr: DoubleArray = doubleArrayOf(1.0,2.02,3.03333)
val booleanArr: BooleanArray = booleanArrayOf(false,true,false)

创建指定长度的数组且无元素，相当于 java中的 int[] intArray = new int[6]

val fixedSizeArr = arrayOfNulls<Int>(6)  //arrayOfNulls<数据类型>(长度)，默认值都是null

• 另外一种是使用工厂函数。如下所示：

val b = Array(3, { i -> (i * 2) })

val arr = Array(3,{it -> it.inc()})  //参数1：数组大小，参数2：一个函数参数的工厂函数
for(i in arr){
    println(i)
}

println(b)    // 输出结果：[Ljava.lang.Integer;@5e481248 (数组对象的地址)
println(b[1])    // 输出结果：2

创建空数组

val empty = emptyArray<Int>()

固定长度的基本类型数组,基本类型数组比Array多一个主构造函数，可以仅用传入长度，就可以创建一个基本类型对象

val intArray = IntArray(3)
val arr = Array(3)  //编译错误

数组的读写(获取数组的长度,修改数组数据)

 val intArr = intArrayOf(1,2,3)
 for(item in intArr){
     println(item)//遍历intArr里面的元素，item就是元素本身
 }
 for (index in intArr.indices){
     println(intArr[index])//遍历initArr索引的元素，从0开始
     println(intArr.get(index))//可以通过get(索引)来获取元素
 }

val a = arrayOf(1, 2, 3)
println(a.size)

val intArr = intArrayOf(1,2,3)
for (index in intArr.indices){
    intArr[index] = 0 //与java一样，可以这样修改数据
    intArr.set(index,1) //kotlin可以通过set函数进行修改数据
}

println(intArr.contentToString())

val a = arrayOf(1, 2, 3)
a[1] = "beijing"  // 报错
println(a[0])

数组的遍历

for循环遍历数组

val a = arrayOf(1, 2, 3)
for (element in a) {
    println(element)
}

forEach遍历数组

val a = arrayOf(1, 2, 3)
a.forEach { element ->
    println(element)
}

val a = arrayOf(1, 2, 3)
a.forEach {
    println(it)
}

其他遍历方式

val a = arrayOf(1, 2, 3)
for (i in 0 until a.size) {
    println(a[i])
}

val a = arrayOf(1, 2, 3)
for (i in a.indices) {
    println(a[i])
}

数组的包含关系（判断一个元素是否在数组中）

val a = arrayOf(1, 2, 3)
if (1 in a) {
    println("1 exists in variable 'a'")
}

if (4 !in a) {
    println("4 not exists in variable 'a'")
}

二维数组

基本类型的二维数组

val arr = Array(3){IntArray(3)} //三个长度为3的Int数组的二维数组
print(arr[1][1])
for (one in arr){
    println()
    for (two in one){
        print(two)
    }
}

 自定义类型的二维数组

fun main() {
    //三个长度为3的Demo类型的二维数组，自定义类型的话需要在大括号里面操作
    val arrClass = Array(3){Array<Demo>(3,{i: Int -> Demo(i) })}
    for (demos in arrClass){
        println()
        for (demo in demos){
            print("${demo.mNum}  ")
        }
    }
}

class Demo(num: Int){
    var mNum: Int? = null
    init {
        this.mNum = num
    }
}