1. Kotlin数组的创建方式

Kotlin创建数组大致有如下两种方式：

1. 使用arrayOf(), arrayOfNulls()，emptyArray()工具函数。
2. 使用使用工厂函数，Array(size: Int, init:(Int) -> T)

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

---

Java中创建数组：

// 创建数组的第一种方法
int[] arr = new int[6];

// 创建数组的第二种方法
int[] x = {1,2,3,4};

// 创建数组的第三种方法。
int[] y = new int[] {1,2,3,4,5};

第一种：arrayOf创建数组

使用arrayOf()创建数组，必须指定数组元素，可以是任意类型

kotlin中的 Any 等价于 Java中的 Object 对象

fun main(args: Array<String>) {
    // 数据类型: Boolean、Shot、Int、Long、Float、Double、Char

    // 创建包含指定元素的数组(Java数组静态初始化)
    val arrString = arrayOf("java", "kotlin"，true, "2", JSONObject())
    println(arrString.contentToString())
    
    val arrInt = arrayOf(1, 2, 3)
    println(arrInt.contentToString())


    // 创建指定长度，元素为null的数组(Java动态初始化)
    val arr2 = arrayOfNulls<String>(6)
    arr2[0] = "Java"
    arr2.set(1, "Kotlin")
    println(arr2.contentToString())
    
    val arr2Double = arrayOfNulls<Double>(8)
    arr2Double[0] = 10.0
    arr2Double.set(1, 22.0)
    println(arr2Double.contentToString())
}

输出结果

[java, kotlin]
[1, 2, 3]
[Java, Kotlin, null, null, null, null]
[10.0, 22.0, null, null, null, null, null, null]

使用arrayOf的完整定义

var string_array:Array<String> = arrayOf("How", "Are", "You")
var int_array:Array<Int> = arrayOf(1, 2, 3)
var long_array:Array<Long> = arrayOf(1, 2, 3)
var float_array:Array<Float> = arrayOf(1.0f, 2.0f, 3.0f)
var double_array:Array<Double> = arrayOf(1.0, 2.0, 3.0)
var boolean_array:Array<Boolean> = arrayOf(true, false, true)
var char_array:Array<Char> = arrayOf('a', 'b', 'c')

第二种：arrayOfNulls创建数组

创建一个指定大小的、所有元素都为空的数组，但必须指定集合中的元素类型

 val arrayOfNulls = arrayOfNulls<String>(5)  //创建一个指定大小的、所有元素都为空的数组

创建实例：

val arrays:Array<String?> = arrayOfNulls<String>(5)
arrays[0] = null
arrays[1] = "kotlin"
println(arrays.contentToString())

• 创建一个指定大小、所有元素都为空的数组，但是必须指定集合中的元素类型
• <String?>是指：代表数组中对象为可空的，即arrays数组可存放空对象

第三种：动态创建数组

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

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

it指的是索引值，{}相当于是一个函数， 可以根据it任意设置

fun main(args: Array<String>) {
    val arrayInt = Array<Int>(5, arrInit())
    val nums1 = 0..4 // 区间表达式，代表0-4
    for (num in nums1) {
        arrayInt[num]
    }
    println(arrayInt.contentToString())


    val arrayInitTwo = Array<Int>(5) { it }
    val nums2 = 0..4
    for (num in nums2) {
        arrayInitTwo[num]
    }
    println(arrayInitTwo.contentToString())


    val b = Array(3) { i -> (i * 2) }
    val nums3 = 0..2
    for (num in nums3) {
        b[num]
    }
    println(b.contentToString())

}

fun arrInit(): (Int) -> Int = { it * 3 }

输出结果

[0, 3, 6, 9, 12]
[0, 1, 2, 3, 4]
[0, 2, 4]

简洁写法

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

    val x: IntArray = intArrayOf(1, 2, 3)
	booleanArrayOf(false, true)
    charArrayOf('a', 'b')
    byteArrayOf(1, 2)
    shortArrayOf(1, 2)
    longArrayOf(1L, 2L)
    floatArrayOf(1F, 2F)
    doubleArrayOf(4.0, 5.0, 6.0)

或者

fun main(args: Array<String>) {
    val empty = emptyArray<Int>()

    val otherArray1 = IntArray(6) {it}

    val otherArray2 = IntArray(6) {it * 2}

    println(empty.contentToString())
    println(otherArray1.contentToString())
    println(otherArray2.contentToString())

}

>>> 输出

[0, 1, 2, 3, 4, 5]
[0, 2, 4, 6, 8, 10]

创建空数组

val emptyArray = emptyArray<Int>()

>>> 输出
[]

创建一个指定大小的、所有元素都为空的数组，但必须指定集合中的元素类型

 val arrayOfNulls = arrayOfNulls<String>(5)  //创建一个指定大小的、所有元素都为空的数组

原生类型数组

在Kotlin中也有无装箱开销的专门的类来表示原生类型数组

原生类型数组	解释
ByteArray	字节型数组
ShortArray	短整型数组
IntArray	整型数组
LongArray	长整型数组
BooleanArray	布尔型数组
CharArray	字符型数组
FloatArray	浮点型数组
DoubleArray	双精度浮点型数组

fun main(args: Array<String>) {
    // 1.创建并初始化一个IntArray  [1, 2, 3, 4, 5]
    val intArray1 = intArrayOf(1, 2, 3, 4, 5)

    // 2.创建一个长度为5的空的IntArray
    val intArray2 = IntArray(5)

    // 3.创建一个长度为5的值全为100的IntArray [100, 100, 100, 100, 100]
    val intArray3 = IntArray(5) { 100 }

    // 4.注意这里it是它索引下标值，所以这是创建一个长度为5的IntArray [0, 2, 4, 6, 8]
    val intArray4 = IntArray(5) { it * 2 }
}

2. 数组的使用

2.1 获取元素

val array =arrayOf(1,2,3,4,5)

array[index] // 获取数组的第index个元素，下标从0开始
array.component1()..array.component5() //获取数组的前5个元素。同样适用于集合

2.2 基本使用

asList() 将该数组转成list的集合

arr.all({it > 20}) 判断是否数组里的值都大于20，如果是返回true，不是返回false

arr.any({it > 20}) 判断是否数组里的值其中有一个大于20，如果是返回true，不是返回false

根据数组元素来计算<K, V>对，返回所有的<K, V>对组成的Map集合。例如 k + 2， v + 10

var arrMap = arr.associate({it + 2 to it + 10})

arr.fill(1, 4, 6) 将数组arr的第5个元素(包括)到底7个元素(不包括)赋值为1

2.3. 遍历数组

方式一

var arr = arrayOf(1, 2, 3)
for (item in arr){
	println(item)
}

方式二：通过索引

var arr = arrayOf(1,2,3)
for (index in arr.indices){
	println(index)
	println(arr[index])
}

方式三：函数式

var arr = arrayOf(1,2,3)
arr.forEach { item ->
	println(item)
}

2.4. 修改数组

for (index in arr.indices){
	// 和Java一样的修改方式
	arr[index]=1
    
	// kotlin 可以set
	arr.set(index,1)
}

2.5. 元素是否在数组内

    var arr = arrayOf(1, 2, 3)

    if ( 1 in arr){
        println("1确实在")
    }

    if ( 5 !in arr){
        println("5确实不在")
    }

2.6. 数组工具方法

Array.forEach()

Array.reverse()

Array.filter()

Array.sort()

Array.any()

Array.count()

Array.find()

Array.map()

Array.flatMap()

Array.find()

Array.flod()

Array.groupBy()