Kotlin学习之集合

原文链接 Kotlin Collections

Kotlin Collections

线性容器

这里并不单纯指类List，主要的意思是线性的容器，它的特点是以相对顺序存储同一类型的对象，有一个整数索引(index)来表示其相对的位置，查找性能差，其他还好。代表为数组。

数组

创建复杂数组

比如数组的元素是一个Collection，而非常见的基本数据类型，这时要如何写？

       val carray = arrayOf<MutableList<Int>>(
            mutableListOf(),
            mutableListOf()
        )

        val narray = Array<MutableList<Int>>(10) { mutableListOf() }

关键就在于要声明元素的类型，其他的与基本数据类型的数组是一样的。另外，如果数组数量比较少，方便直接写，那就用字面构造函数，其实很方便。或者用数组元素的构造方法也可以。

多维数组

以最为常见的二维数组来说，要如何创建?

       val smatrix = arrayOf(
            arrayOf(1, 2, 3),
            arrayOf(4, 5, 6),
            arrayOf(7, 8, 9)
        )

        val matrix = Array(5) { IntArray(6) }

Ranges

if (i in 1..4) { // equivalent of i >= 1 && i <= 4
    print(i)
}

for (i in 1..4) print(i) // for (int i = 1; i <= 4; i++) print(i)

for (i in 0 until 10) { // for (int i = 0; i < 10; i++)
    print(ln)
}

for (i in 0 until 10 step 2) { // for (int i = 0; i < 10; i += 2)
    print(ln)
}

for (i in 9 downTo 0) { // for (int i = 9; i >= 0; i--)
    print(i)
}

for (c in 'a'..'z') { // for (char c = 'a'; c <= 'z'; c++)
    print(c)
}

    for (i in (0..9).filter {it % 2 == 0 }) {
        println(i) // only evens
    }
    for (c in ('a'..'z').map { it.toUpperCase() }) {
        println(c) // upper case
    }

for ((index, value) in array.withIndex()) {
    println("the element: [$index] = $value")
}

注意与repeat的区别

Ranges是一个数据结构代表着一个区间，这个区间可能是一个整数范围，也可能是一个字符范围，其实也可以是其他自定义数据类型，只要能表达 出区间的概念。只不过整数区间是为常用的一种方式，以及整数区间可以方便当作数组和列表的索引。

但有时如果仅仅想重复一件事情n次，那就没有必要用Ranges，虽然它也可以，这时最为方便的是函数repeat，它与区间的唯一区别是repeat是没有返回值的，它仅是把一件事情重复n次，但没有返回值也就是说没有办法再转化为其他数组或者列表。

repeat(10) { println("repeat # $it") }
//repeat # 0
//repeat # 1
//repeat # 2
//repeat # 3
//repeat # 4
//repeat # 5
//repeat # 6
//repeat # 7
//repeat # 8
//repeat # 9

而比如Ranges是可以转化为其他数组和列表的：

(0 until 5).map { it * it }.toIntArray()
// [0, 1, 4, 9, 16]

列表List

val names = listOf("James", "Donald", "Kevin", "George")
names.map { it.toUpper() }
	.forEach { println(it) }

序列Sequence

队列queue

队列可以用双端队列deque（读作dek），具体实现对象是ArrayDeque<T>。

双端队列是强大的数据结构，即可以用作队列，也可以用作栈。

Set容器

Set是一个不含有重复元素的容器，特点是不会保存相对顺序，可以快速实现检索。

    val names = setOf("James", "Harden", "Donald", "Joe")
    for (nm in names) {
        println(nm)
    }
    names.filter { it.length > 4 }
        .forEach { println(it) }

Map容器

由映射键->值对组成的二维容器，键不可重复，值可以重复，不会保存相对顺序，也可以用于快速检索。

    val nameMap = mapOf("James" to 15, "Harden" to 30, "Donald" to 80, "Joe" to 86)
    for (nm in nameMap.keys) {
        println(nm)
    }
    for (age in nameMap.values) {
        println(age)
    }
    for (e in nameMap.entries) {
        println("${e.key} is ${e.value}")
    }
    nameMap.filter { it.key.length > 5 }
        .forEach { println("${it.key} = ${it.value}") }

注意Immutability

有一个地方需要特别注意，那就是容器的不可变性Immutability，用常规的方法创建的集合对象是不可变的Immutable，就是无法向其中添加元素也无法删除元素。对象的不可变Immutable在函数式编程中是很重要的特性可以有效的减少异步和并发带来的状态一致性问题。

val names = listOf("James", "Donald", "Kevin", "George")
names.add("Paul") // compile error, names is immutable
names.map { it.toUpper() }
	.forEach { println(it) }

这样写会有编译错误，因为用listOf创建的列表对象是不可变的Immutable。如果想要改变就必须用支持更改的对象，如MutableList, MutableSet和MutableMap，如：

val names = mutableListOf("James", "Donald", "Kevin", "George")
names.add("Paul") // okay
names.map { it.toUpper() }
	.forEach { println(it) }

如果有可能还是要尽可能的用不可变对象(Immutable objects)。

集合的操作

集合的操作就是函数式的三板斧过滤filter，转化map和折叠化约fold/reduce，前面讲的所有的容器都是支持的，结合lambdas可以写出非常规范的函数式代码。

参考资料

• Kotlin Collections
• Kotlin常用Collection集合操作整理
• Kotlin Collections Guide
• Kotlin Ranges

原创不易，打赏，点赞，在看，收藏，分享 总要有一个吧