集合
与多数语言不一样,Kotlin区分可变与不可变集合(list,sets,maps等等)。精确控制什么时候可以编辑集合有利于减少BUG和设计良好的API。
在这之前,理解只读的可变集合与实际不变的集合的区别很有必要。两者创建都很容易,但是类型系统表达却不相同。
Kotlin的List<out T>类型是一个接口,提供只读操作如size,get等等。与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)
}
整形类型区间(IntRange,LongRange,CharRange)有个额外的特性:可以循环迭代。编译器可以将区间转为近似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
整型数列(IntProgression,LongProgression,CharProgression)表示算数队列。数列使用起始元素,末尾元素和非零步数定义。首位元素为起始元素,子队列元素为前一个元素加上步数,末尾元素总要循环命中(除非队列为空)。
队列为Iterable<N>子类,N表示Int,Long,Char,所以可以在for循环和像map,filter等函数中使用。队列循环近似与Java中的索引for循环
for (int i = first; i != last; i += step) {
// ...
}
对于整型,..操作符会创建实现ClosedRange<T>和*Progression接口的对象。如IntRange实现ClosedRange<Int>并继承IntProgression,因此所有为IntProgression定义的操作符都用于IntRange。downTo()和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)
//...
}
浮点数(Double,Float)没有定义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]