数组和集合

1. 数组

kotlin为数组增加了一个Array类，为元素是基本类型的数组增加了xxArray类（其中xx也就是Byte，Short， Int等基本类型）

1. 创建数组的方式
   1、使用arrayOf(), arrayOfNulls()，emptyArray()工具函数
   2、使用Array(size: Int, init:(Int) -> T)

fun testArray() {
    // 包含特殊元素的数组,相当于 java 中的静态初始化
    val array = arrayOf("scs", "sdcs", "sdcsdc")
    val arrayInt = arrayOf(1, 11, 1, 1, 2)
    // 创建定长数组
    val arrayList = arrayOfNulls<Int>(10)
    val arrInt = intArrayOf(1, 1, 1, 2)
    val arrDouble = doubleArrayOf(1.0, 1.0, 1.0, 2.0)
}

我们知道 kotlin 方法的参数是可以传函数的，还有一种数组创建的方式

fun testArray() {
    // 带方法的Int数组
    val array = Array(10) { num -> num }
    // 输出 0,1,2,3,4,5,6,7,8,9
    array.forEach {
        Log.e("test", "array:$it")
    }
    val array1 = Array(10) { num -> num * 10 }
    // 输出 0,10,20,30,40,50,60,70,80,90
    array1.forEach {
        Log.e("test", "array1:$it")
    }
}

2. 数组还提供了丰富的 api

fun testArray() {
    // 带方法的Int数组
    val array = Array(10) { num -> num }
    // 转化为 list
    val list = array.asList()
    // 判断数组里的值是否都大于 20,否则返回 false
    var b = array.all { it > 20 }
    // 数组中有一个数字大于 2,就返回 true
    array.any { it > 2 }
    // 返回一个 map 集合,<k,v>的值就是<it + 1,it + 2>
    val arrayMap = array.associate { it + 1 to it + 2 }
    arrayMap.forEach {
        Log.e("test", "key:${it.key}")
        Log.e("test", "value:${it.value}")
    }
    // 把数组中的第 4 位(包括)到底 9 位(不包括)赋值为 1
    array.fill(1, 4, 9)
    array.forEach {
        Log.e("test", "it:$it")
    }
}

2. 集合

kotlin集合类同样有两个接口派生：Collection和Map。但Kotlin的结合被分成两个大类，可变集合和不可变集合。只有可变集合才可以添加修改，删除等处理操作。不可变集合只能读取元素。

kotlin只是提供HashSet，HashMap， LinkedHashSet， LinkedHashMap， ArrayList这5个集合实现类，而且他们都是可变集合。

1. set 集合

fun testArray() {
    // 创建一个不可变的 set 集合
    var set = setOf("sdc", "sdcsd")
    // 创建一个可变的 MutableSet 集合
    var mutableset = mutableSetOf(1, 2, 3, 4)
    // 创建一个可变的 hashSet 集合
    var hashSet = hashSetOf(1, 2, 3)
    // 创建一个可变的 linkedHashSet 集合
    var linkedHashSet = linkedSetOf(1, 2, 3)
    // 创建一个可变的 TreeSet 集合
    var sortedSet = sortedSetOf(1, 2, 3)
    // 返回删除前两个元素后的集合
    var list = mutableset.drop(2)
    list.forEach {
        Log.e("test", "list:$it")
    }
    // 集合里面包含"s"元素则返回 true,否则返回 false
    set.filter { "s" in it }
}

2. list 集合

fun testArray() {
    // 创建
    // 返回不可变的 list 集合
    var list = listOf("sdcs", "sdcs", "java")
    // 返回不可变的集合,自动过滤掉 null
    var listOfNotNull = listOfNotNull("asdcsa", null, "asdcasd")
    listOfNotNull.forEach {
        Log.e("test", "listOfNotNull:$it")
    }
    // 返回一个可变的 MutableList 集合
    var mutableList = mutableListOf(1, 2, 3, 4, 5)
    // 使用方法
    // 返回对应的下标
    list.indexOf("java")
    // 返回子集合 包含 1 不包含 3
    var subList = list.subList(1, 3)
    subList.forEach {
        Log.e("test", "subList:$it")
    }
}

3. map 集合

fun testArray() {
    // 创建一个不可变的 map 集合
    var map = mapOf("1" to "sdcsd1", "2" to "sdcsd2", "3" to "sdcsd3")
    // 创建一个可变的 MutableMap 集合
    var mutableMap = mutableMapOf(1 to "sdc1", 2 to "sdc2", 3 to "sdc3")
    // 创建一个可变的 HashMap 集合
    var hashMap = hashMapOf(1 to "sdc1", 2 to "sdc2", 3 to "sdc3")
    // 判断所有的元素 key>2, value.length > 2则返回 true,否则返回false
    mutableMap.all { it.key > 2 && it.value.length > 2 }
    // 遍历
    for (en in map.entries) {
        Log.e("test", "en:key:${en.key} value:${en.value}")
    }
    // 遍历 key
    for (key in map.keys) {
        Log.e("test", "key:$key")
    }
    // 遍历 value
    for (value in map.values) {
        Log.e("test", "value:$value")
    }
}