Kotlin-2数组与列表

Kotlin学习 —— 2.数组与列表

1. 数组Array

数组用类 Array 实现，可以采用[]和get/set的两种方式进行访问修改。Kotlin中的数组是不能型变的，也就是说Array不能赋值给Array

定义方式：arrayOf()、工厂函数

操作：array[index]=value，array.set(index,value)

常用方法：

1. copyOf()//复制，返回一个数组

2. reverse()//反转

3. reversed()//反转，返回一个反转后的列表

4. plus(element)//添加内容（子项或数组），返回一个添加后的数组。本质是新建一个n+1的数组，复制后并返回

5. fill(element,start,end)//修改start到end的子项为element，不包括end

6. asList()//返回一个List，对数组操作会影响到list

7. toList()//复制并返回一个list，对数组操作不会影响到list

8. toMutableList()//复制并返回一个可变list，与toList()的区别看源码

    public fun <T> Array<out T>.toList(): List<T> {
        return when (size) {
            0 -> emptyList()
            1 -> listOf(this[0])
            else -> this.toMutableList()
        }
    }
   

举个栗子：

fun testArray() {
    //定义时初始化
    val students = arrayOf("Tom","Jerry","Ryan")
    for (student:String in students){
        LogUtil.e(student)
    }
    LogUtil.e("-------------------------------------------")
    //先定义（需要传大小）后添加
    val students1 = arrayOfNulls<String>(4)//值全为null，即使是Int或其它类型，值还是null
    students1[0] = "Tom"//赋值
    students1[1] = "Jerry"
    students1[2] = "Ryan"
    for (student: String? in students1) {
        LogUtil.e(student)
    }
    LogUtil.e("-------------------------------------------")
    //工厂函数定义
    val student2 = Array(3){ k-> "结果：$k"}
    for (student: String in student2) {
        LogUtil.e(student)
    }
}

二维数组：val arr2 = Array(3){Array(3)}

三维数组：val arr3 = Array(3){Array(3){Array(3){}}}

多维数组：val arr = Array(x){…}//多层嵌套

自定义数组：

    val arrClass = arrayOf(
        arrayOf(UserBean(1),2),
        arrayOf("3",false),
        arrayOf(5f,6.55)
    )

2. 列表List

列表分为可变列表和不可变列表

定义方式：

1. listOf()不可变，返回一个List，可通过 toMutableList() 转换为可变的
2. mutableListOf()可变，返回 MutableList
3. arrayListOf()可变，返回 ArrayList

2、3区别：ArrayList 继承 MutableList，RandomAccess，就像Java中的 List 和 ArrayList

常用方法：与java基本一致，可通过 toTypedArray() 转换为数组

举个栗子：

fun testList() {
    var list1 = listOf("1","2","3")
    var list2 = mutableListOf("1","2","3")
    var list3 = arrayListOf("1","2","3")
    list2.add("a")
    list3.remove("2")
    list3.set(1,"a")
}

//scan()列表值累加
//scan()等方法是实验性的 ExperimentalStdlibApi
val strings = listOf("a", "b", "c", "d")
println(strings.scan("s") { acc, string -> acc + string }) // [s, sa, sab, sabc, sabcd]
println(strings.scanIndexed("s") { index, acc, string -> acc + string + index }) // [s, sa0, sa0b1, sa0b1c2, sa0b1c2d3]

scan()相关资料

3. Set

不重复，可用与去重。分为可变和不可变

定义方式：

fun testSet(){
    var set = setOf("a","b")            //返回-不可变-Set
    var set1 = emptySet<String>()       //返回-不可变-Set
    var set2 = mutableSetOf<String>()   //返回-可变-LinkedHashSet
    var set3 = hashSetOf<String>()      //返回-可变-HashSet
    var set4 = linkedSetOf<String>()    //返回-可变-LinkedHashSet
    var set5 = sortedSetOf<String>()    //返回-可变-TreeSet
    for (value in set) {
        LogUtil.e("value = $value")
    }
}

常用方法：与java基本一致，可通过 toList()、toMutableList() 转换为包含key-value的list

public fun <T> Iterable<T>.toList(): List<T> {
    if (this is Collection) {
        return when (size) {
            0 -> emptyList()
            1 -> listOf(if (this is List) get(0) else iterator().next())
            else -> this.toMutableList()
        }
    }
    return this.toMutableList().optimizeReadOnlyList()
}

public fun <T> Collection<T>.toMutableList(): MutableList<T> {
    return ArrayList(this)
}

4. Map

key-value存储方式，key唯一，value可重复，分为可变和不可变

定义方式：

fun testMap(){
    var map = mapOf<String,String>("key1" to "value1","key1" to "value2","key2" to "value1")
    var map1 = emptyMap<String,String>()        //返回-不可变-LinkedHashMap
    var map2 = mutableMapOf<String,String>()    //返回-可变-LinkedHashMap
    var map3 = hashMapOf<String,String>()       //返回-可变-HashMap
    var map4 = linkedMapOf<String,String>()     //返回-可变-LinkedHashMap
    var map5 = sortedMapOf<String,String>()     //返回-可变-TreeMap
    for (key in map.keys) {
        LogUtil.e("key = $key，value = ${map[key]}")
    }
    for ((key,value) in map){
        LogUtil.e("key = $key，value = $value")
    }
}

mapOf() 和 mutableMapOf() 都是返回 LinkedHashMap ，为避免以后出现问题，所以一般用 hashMapOf() 和 linkedMapOf()

常用方法：与java基本一致，可通过 toList() 转换为包含key-value的list

public fun <K, V> Map<out K, V>.toList(): List<Pair<K, V>> {
    if (size == 0)
        return emptyList()
    val iterator = entries.iterator()
    if (!iterator.hasNext())
        return emptyList()
    val first = iterator.next()
    if (!iterator.hasNext())
        return listOf(first.toPair())
    val result = ArrayList<Pair<K, V>>(size)
    result.add(first.toPair())
    do {
        result.add(iterator.next().toPair())
    } while (iterator.hasNext())
    return result
}