Kotlin进阶之集合与区间

Posted by AlexWan on 2017-07-17

集合

与多数语言不一样,Kotlin区分可变与不可变集合(list,sets,maps等等)。精确控制什么时候可以编辑集合有利于减少BUG和设计良好的API。

在这之前,理解只读的可变集合与实际不变的集合的区别很有必要。两者创建都很容易,但是类型系统表达却不相同。

Kotlin的List<out T>类型是一个接口,提供只读操作如sizeget等等。与Java相同,继承Collection<T>接口,Collection<T>继承Iterable<T>MutableList<T>添加了修改数组的方法。同样模式还有Set<out T>/MutableSet<T>Map<K, out V>/MutableMap<K, V>

List与Set的基础用法

val numbers: MutableList<Int> = mutableListOf(1, 2, 3)
val readOnlyView: List<Int> = numbers
println(numbers) // 输出"[1, 2, 3]"
numbers.add(4)
println(numbers) // 输出"[1 , 2, 3, 4]"
readOnlyView.clear() // 不会通过编译
val strings = hashSetOf("a", "b", "c", "c")
assert(strings.size == 3)

Kotlin没有创建列表或Set的专用语法,可以使用如listOf()mutableListOf()setOf()mutableSetOf()创建。在非性能严格的代码中,可以使用简单的惯用语法实现:mapOf(a to b, c to d)

readOnlyView变量指向相同list,像基本List改变一样改变。如果唯一引用指向只读变量List,则认为集合整体不可变。

创建不可变集合的一个简单方法:

val items = listOf(1, 2, 3)

目前,listOf方法使用数组List实现,但在未来可能会返回存储效率更高的完全不可变的集合类型。

只读类型为协变量,意味可是使用List<Rectangle>赋值给List<Shape>(假设Rectangle继承Shape)。在可变集合中则不被允许,因为在运行时,可变集合可能允许出错。

有时希望及时返回集合快照给调用者,保证集合不变。

class Controller {
private val _items = mutableListOf<String>()
val items: List<String> get() = _items.toList()
}

toList扩展函数只是List的副本,返回的List保证不会改变。

还应该熟悉List和Set的一些有用的扩展方法

val items = listOf(1, 2, 3, 4)
items.first() == 1
items.last() == 4
items.filter { it % 2 == 0 } // 返回[2 , 4]
val rwList = mutableListOf(1, 2, 3)
rwList.requireNoNulls() // 返回 [1, 2, 3]
if (rwList.none { it > 6 }) println("No items above 6") // 输出 "No items above 6"
val item = rwList.firstOrNull()

同样的还有其他如排序压缩折叠减少等可能需要的实用方法。

Map采取相同模式,可以像如下实例化和访问。

val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
println(readWriteMap["foo"]) // 输出"1"
val snapshot: Map<String, Int> = HashMap(readWriteMap)

区间

使用rangeTo函数行成的区间表达式,可以使用..形式的操作符,并使用in!in补全。Kotlin为任意比较类型定义的区间,对于整型基本类型则有自己最优化的实现。如:

if( i in 1..10){ // 与 1 <= i && i <= 10相等
println(i)
}

整形类型区间(IntRangeLongRangeCharRange)有个额外的特性:可以循环迭代。编译器可以将区间转为近似Java的for循环,而没有额外的开销。

for ( i in 1..4) print(i) // 输出 "1234"
for (i in 1..4) print(i) // 无任何输出

如果希望逆序循环,可通过标准库中定义的downTo函数

for (i in 4 downTo 1) print(i) // 输出 "4321"

循环通过step函数来指定单循环步数

for(i in 1..4 step 2) print(i) // 输出"13"
for(i in 4 downTo 1 step 2) print(i) // 输出"42"

使用until函数创建不包括结尾元素的循环迭代操作

for( i in 1 until 10 ){ // i in [1 , 10) 不包括10
println(i)
}

实现原理

区间实现库中的一个通用的接口:ClosedRange<T>

ClosedRange<T>表示数学意义上的闭合区间,为比较类型定义。有两个端点:起始结束,两点都包含在区间内。主要操作符是contains,使用形式in!in

整型数列(IntProgressionLongProgressionCharProgression)表示算数队列。数列使用起始元素,末尾元素和非零步数定义。首位元素为起始元素,子队列元素为前一个元素加上步数,末尾元素总要循环命中(除非队列为空)。

队列为Iterable<N>子类,N表示IntLongChar,所以可以在for循环和像mapfilter等函数中使用。队列循环近似与Java中的索引for循环

for (int i = first; i != last; i += step) {
// ...
}

对于整型,..操作符会创建实现ClosedRange<T>*Progression接口的对象。如IntRange实现ClosedRange<Int>并继承IntProgression,因此所有为IntProgression定义的操作符都用于IntRangedownTo()step()函数返回值为*Progression

使用fromClosedRange函数构建的队列,定义在它们的伴生对象中:

IntProgression.fromClosedRange(start, end, step)

队列末尾元素用于计算查找step为正数时不超过end值的最大值,或step为负数是不小于end的最小值(last - first) % step == 0

工具函数

rangeTo()

整型的rangeTo()操作符就是调用*Range的构造方法

class Int{
//...
operator fun rangeTo(other: Long): LongRange = LongRange(this, other)
//...
operator fun rangeTo(other: Int): IntRange = IntRange(this, other)
//...
}

浮点数(DoubleFloat)没有定义rangeTo操作符,使用标准库提供的泛型Comparable类型替代。

public operator fun <T: Comparable<T>> T.rangeTo(that: T): ClosedRange<T>

这个函数的返回区间不能用于循环迭代。

downTo()

为整型定义的downTo() 扩展函数,如:

fun Long.downTo(other: Int): LongProgression {
return LongProgression.fromClosedRange(this, other.toLong(), -1L)
}
fun Byte.downTo(other: Int): IntProgression {
return IntProgression.fromClosedRange(this.toInt(), other, -1)
}

reversed()

为每个*Progression类定义reversed()扩展函数,返回反转的数列

fun IntProgression.reversed(): IntProgression {
return IntProgression.fromClosedRange(last, first, -step)
}

step()

*Progression定义step()扩展函数,返回使用step值过滤后的数列。step值要求总要为正数,因此这个不会修改循环方向。

fun IntProgression.step(step: Int): IntProgression {
if (step <= 0) throw IllegalArgumentException("Step must be positive, was: $step")
return IntProgression.fromClosedRange(first, last, if (this.step > 0) step else -step)
}
fun CharProgression.step(step: Int): CharProgression {
if (step <= 0) throw IllegalArgumentException("Step must be positive, was: $step")
return CharProgression.fromClosedRange(first, last, if (this.step > 0) step else -step)
}

函数返回的数列末尾值可能会与原队列末尾值不同,保证(last - first) % step == 0

(1..12 step 2).last == 11 // 队列 [1, 3, 5, 7, 9, 11]
(1..12 step 3).last == 10 // 队列 [1, 4, 7, 10]
(1..12 step 4).last == 9 // 队列 [1, 5, 9]