[移动开发]Kotlin学习——集合（二）

区间与数列

Kotlin 可以通过调用 kotlin.ranges 包中的 rangeTo() 函数及其操作符形式的 .. 轻松地创建两个值的区间。通常，rangeTo() 会辅以 in 或 !in 函数

if( i in 1..4){ //等同于 1 <= i && i <= 4
   print(i)
}

for( i in 1..4) print(i)

//反向迭代，使用 downTo
for( i in 4 down 1) print(i)

//通过 step 设置步长进行迭代
for( i in 1..8 step 2) print(i)
for( i in 8 downTo 1 step 2) print(i)

//迭代不包含其结束元素的数字区间，使用 until 函数
for( i in 1 until 10) // i in [1,10) ,10被排除

区间

由两个端点值定义，这两个端点值都包含在该区间内。区间是为可比较类型定义的：具有顺序，可以定义任意实例是否在两个给定实例之间的区间内。

区间的主要操作是 contains，通常以 in 与 ！in 操作符的形式使用

要为类创建一个区间，请在区间起始值上调用 rangeTo() 函数，并提供结束值作为参数。 rangTo() 通常以操作符 .. 形式调用

数列

整数类型的区间（例如 Int、Long 与 Char）可视为等差数列。在 Kotlin 中，这些数列由特殊类型定义：IntProgression、LongProgression 与 CharProgression

数列具有三个基本属性：first 元素、last 元素 和 一个非零的 step。首个元素为 first，后续元素是前一个元素加step。除非数列为空，否则最后一个元素总是被迭代命中。

序列（Sequence<T>)

序列提供与 Iterable 相同的函数，但实现另一种方法来进行多步骤集合处理。

当 Iterable 的处理包含多个步骤时，它们会优先执行：每个处理步骤完成并返回其结果——中间集合。在此集合上执行以下步骤。反过来，序列的多步处理在可能的情况下会延迟执行：仅当请求整个处理链的结果时才进行实际计算。

操作执行的顺序也不同：Sequence 对每个元素逐个执行所有处理步骤。而 Iterable 完成整个集合的每个步骤，然后进行下一步

所以，序列可以避免生成中间步骤的结果，从而提高整个集合处理链的性能。但是，序列的延迟性质增加了一些开销，这些开销在处理较小的集合或进行更简单的计算时可能很重要。

构造

由元素

要创建一个序列，需调用 sequenceOf() 函数，列出元素座位其参数

val numberSequence = sequenceOf("four", "three", "two", "one")

由 Iterable

如果已经有一个 Iterable 对象（例如 List 或 Set），则可以通过调用 asSequence() 从而创建一个序列。

val numbers = listOf("one", "two")
val numbersSequence = numbers.asSequence()

由函数

创建序列的另一种方法是痛殴使用计算其元素的函数来构建序列。要以该函数作为参数调用 generateSequence() 。可以将第一个元素指定为显示值或函数调用的结果。当提供的函数返回 null 时，序列生成停止。

val oddNumbers = generateSequence(1){ it + 2}  //it是上一个元素
println(oddNumbers.take(5).toList())
println(oddNumbers.count()) //错误：此序列是无限的 

要使用 generateSequence() 创建有限序列，需提供一个函数，该函数在需要的最后一个元素之后返回 null

val oddNumbersLessThan10 = generateSequence(1){ if(it < 10) it + 2 else null }
println(oddNumbersLessThan10.count())

由组块

sequence() 函数可以逐个或按任意大小的组块生成序列元素，此函数采用一个 lambda 表达式，其中包含 yield() 与 yieldAll() 函数的调用。它们将一个元素返回给序列使用者，并暂停 sequence() 的执行，直到使用者请求下一个元素。

yield() 使用单个元素作为参数

yieldAll() 中可以采用 Iterable 对象、Iterable 或 其他 Sequence； 该函数的 sequence 参数可以是无限的。当然，这样的调用必须是最后一个，之后的所有调用都永远不会执行

val oddNumbers = sequence{
    yield(1)
    yieldAll(listOf(3, 5))
    yieldAll(generateSequence(7){ it + 2} )
}

println(oddNumbers.take(5).toList())

序列操作

关于序列操作，根据其状态要求可以分为以下几类：

• 无状态：操作不需要状态，并且可以独立处理每个元素，例如 map() 或 filter()。无状态操作海可能需要少量常数个状态来处理元素。例如 take() 与 drop()
• 有状态：操作需要大量状态，通常与序列中元素的数量成正比例

如果序列操作返回延迟生成的另一个序列，则称为中间序列。否则，该操作为末端操作。末端操作的示例为 toList() 或 sum()。只能通过末端操作才能检索序列元素。

常用函数

take

take()：?根据传入的参数挑出该集合【前 n 个元素】的子集合

takeLast(): 根据传入的参数挑出该集合【倒数n个元素】的子集合

takewhile()：从头开始取值，不符合立即停止

takeLastWhile()：从尾开始趋之，不符合立即停止

takeIf()：如果满足条件则返回它

takeUnless()：如果不满足条件则返回它

val mList = mutableListOf(1,2,3,4,5,6,7,8,9,0)
val nNewList1 = mList.take(2)
val nNewList2 = mList.takeLast(2)
val nNewList3 = mList.takeWhile{
    it % 2 == 0
}
val nNewList4 = mList.takeLastWhile{
    it % 2 == 0
}
val nNewList5 = mList.takeIf{
    it.size == 10
}//1,2,3,4....

val nNewList51 = mList.takeIf{
    it.size == 5
}//null

val nNewList6 = mList.takeUnless{
    it.size == 10
}//null

val nNewList61 = mList.takeUnless{
    it.size == 5
}//1,2,3,4...

drop

drop()：去掉前n个开始取值

dropLast()：去掉最后 n 个开始趋之

dropLastWhile()：从最后开始找不满足的开始取值，满足的抛弃尾部

dropWhile()：从头开始找不满足的开始取值，满足的抛弃头部