• 对象数组
• 基本数据类型数组

  数据容器是基于某种数据结构的，常见的数据结构有数组 (Array)、集 (Set)、队列 (Queue)、链表 (Linkedlist)、树 (Tree)、堆 (Heap)、栈 (Stack) 和 映射 (Map) 等结构。

• 数组

  数组 (Array) 是一种罪基本的数据结构，数组具有三个基本特性：
  (1) 一致性。数组只能保持相同数据类型的元素；
  (2) 有序性。数组中的元素是有序的，通过下标访问，数组的下标从零开始；
  (3) 不可变性。数组一旦初始化，则长度（数组中元素的个数）不可变。

  为兼容 Java 中数组和提高访问效率，Kotlin 将数组分为 对象数组 和 基本数据类型数组。

一、对象数组

  kotlin 对象数组是 Array<T>，其中只能保存对象，这里对象对应的是 Java 中的对象，例如 Java 中的 int 只是基本数据类型，而 Integer 才是 Java 对象。

  下面是 Kotlin 中8种数据类型数组，与编译后的 Java 代码比较。

// kotlin 8种基本数据类型数组

fun main(args: Array<String>?) {
    val ints: Array<Int> = arrayOf(1)
    val shorts: Array<Short> = arrayOf(1)
    val btyes: Array<Byte> = arrayOf(3)
    val longs: Array<Long> = arrayOf(34)

    val floats: Array<Float> = arrayOf(23.2f)
    val doubles: Array<Double> = arrayOf(3.3)
    val chars: Array<Char> = arrayOf('a')
    val booleans: Array<Boolean> = arrayOf(false)
}

// kotlin 通过转换编译后的 java 代码

@Metadata(
   mv = {1, 1, 15},
   bv = {1, 0, 3},
   k = 2,
   d1 = {"\u0000\u0014\n\u0000\n\u0002\u0010\u0002\n\u0000\n\u0002\u0010\u0011\n\u0002\u0010\u000e\n\u0002\b\u0002\u001a\u001b\u0010\u0000\u001a\u00020\u00012\u000e\u0010\u0002\u001a\n\u0012\u0004\u0012\u00020\u0004\u0018\u00010\u0003¢\u0006\u0002\u0010\u0005¨\u0006\u0006"},
   d2 = {"main", "", "args", "", "", "([Ljava/lang/String;)V", "kotlin_module"}
)
public final class WwwwKt {
   public static final void main(@Nullable String[] args) {
      Integer[] var10000 = new Integer[]{1};
      Short[] var9 = new Short[]{Short.valueOf((short)1)};
      Byte[] var10 = new Byte[]{3};
      Long[] var11 = new Long[]{34L};
      Float[] var12 = new Float[]{23.2F};
      Double[] var13 = new Double[]{3.3D};
      Character[] var14 = new Character[]{'a'};
      Boolean[] var15 = new Boolean[]{false};
   }
}

  注意：通过上面的编译对比，kotlin 对象数组中保存的8中基本类型的数据，他们都会编译成 Java 包装类数组，而不是 Java 基本数据类型数组。即如下对应关系：

二、基本数据类型数组

kotlin 中创建对象数组有3中方式：

• arrayOf(vararg elements: T) 工厂函数：指定数组元素列表，创建元素类型为 T 的数组，vararg 表明参数个数是可变的。

• arrayOfNulls<T>(size: Int) 函数：size 参数指定数组大小，创建元素为 T 的数组，数组中的元素为空值(即：null)。

• Array(size: Int, init: (Int) -> T) 构造函数：通过 size 参数指定数组大小，init 参数指定一个用于初始化元素的函数，实际使用时经常是 Lambda 表达式，索引值从0开始。

fun <T> printArray(array: Array<T>) {
    val printStr = if (array.isEmpty()) "[]" else array.joinToString(", ", "[", "]")
    println(printStr)
}

fun main(args: Array<String>?) {
    val array1 = arrayOf(1, 2, 4, 5, 6)
    val array2 = arrayOfNulls<Char>(3)
    array2[0] = 'a'
    array2[1] = 'b'
    val array3 = Array<Int>(5) { it * it } // 尾随lambda表达式
    val array4 = Array<String>(3) { i -> "张家老$i" }
    val array5 = arrayOfNulls<Boolean>(0)
    printArray(array1)
    printArray(array2)
    printArray(array3)
    printArray(array4)
    printArray(array5)
}

2019-06-12 10:40:30.649 5875-5875/cn.ak.kot I/System.out: [1, 2, 4, 5, 6]
2019-06-12 10:40:30.650 5875-5875/cn.ak.kot I/System.out: [a, b, null]
2019-06-12 10:40:30.650 5875-5875/cn.ak.kot I/System.out: [0, 1, 4, 9, 16]
2019-06-12 10:40:30.650 5875-5875/cn.ak.kot I/System.out: [张家老0, 张家老1, 张家老2]
2019-06-12 10:40:30.650 5875-5875/cn.ak.kot I/System.out: []

  Array(size: Int, init: (Int) -> T) 构造函数可以表示为Array<Int>(10, {i -> i * i})或者Array<Int>(10){i -> i * i}，后者称为尾随 Lambda 表达式，使用尾随 Lambda 表达式的前提是，一个函数的最后一个参数是函数类型，在用 Lambda 表达式为实际参数时，可以将 Lambda 表达式移到函数的小括号之后，详细关于 Lambda 表达式使用可以查看《Kotlin函数式编程 (2)Lambda表达式》。