kotlin 特殊集合之序列

kotlin 特殊集合之序列

文章目录

  • kotlin 特殊集合之序列
    • 正文
        • 1. 先看段代码,直观感受序列的优点,速度快
        • 2. sequence 创建
        • 3. 更深一步看 sequence 的原理
        • 4. sequence 懒加载优点

正文

1. 先看段代码,直观感受序列的优点,速度快

/**[1] 序列操作又称惰性集合操作,在对集合进行链式操作(映射、过滤、变换),不需要像普通集合那样,每进行一次数据操作都需要开辟新的内存存储中间结果
 * Author: hc
 * DATE: 2019-09-25 = 12:05
 */
fun main(args: Array<String>) {
    //[2] 普通集合处理
    //10000000 数量: 耗时 155
    //1_0000_0000 级别:5462
    computeRunTime { (0..1_0000_0000)
        .filter { it% 10 == 0 }
        .map { it / 10 }
        .sum().run {
            println("by using sequences way, result is : $this")
        }}

    //[3] 转换成序列 来做处理
    //10000000 数量: 耗时 104
    //1_0000_0000 级别: 856
    computeRunTime { (0..1_0000_0000)
        .asSequence()
        .filter { it% 10 == 0}
        .map { it / 10 }
        .sum().run {
            println("by using sequences way, result is : $this")
        }}
}

fun computeRunTime(action: (() -> Unit)?){
    //计时
    val startTime = System.currentTimeMillis()
    action?.invoke()
    println("\"the code run time is ${System.currentTimeMillis() - startTime}")
}

2. sequence 创建

//[1] 类似 listOf 方式
val seq = sequenceOf("a", "b", "c")

//[2] 列表使用 asSequence 方法,上面就是这个方式
val list = listOf("a", "b", "c")
list.asSequence()

//[3] 使用 lambda 表达式, 0 代表第一个元素
val seq = generateSequence(1) { it + 2 }
//生成 10个
println(seq.take(10).forEach { println(it) })

3. 更深一步看 sequence 的原理

//[1] 下面的代码和输入,可以看到普通列表的流式表达式是一个个执行下去,类似广度优先,这在 filter 、take 这种命令就会浪费;
// 而 sequence 就是一个执行到位在执行下一个,类似深度优先
fun main2() {
    val LARGE_V = 1_0000_0000
    val normal_v = 10

    (0..normal_v)
        .map {
            println("map1 ")
            it / 10
        }
        .take(2)
        .map {
            println("map2 ")
            it * 10
        }
        .sum().run {
            println("by using sequences way, result is : $this")
        }
    /* 输出
    map1 
    .. (8个) 
    map1 
    map2 
    map2 
     */

    (0..normal_v)
        .asSequence()
        .map {
            println("map1 ")
            it / 10
        }
        .take(2)
        .map {
            println("map2 ")
            it * 10
        }
        .sum().run {
            println("by using sequences way, result is : $this")
        }
    /* 输出:
    map1 
    map2 
    map1 
    map2 
     */
}

4. sequence 懒加载优点

- 一旦满足遍历退出条件,就可以省略后续不必要的遍历过程
- 像List 这种实现 Iterable 接口的集合类,每调用一次函数就会生成一个新的 Iterable ,导致额外的内存消耗

你可能感兴趣的:(Kotlin,学习笔记系列)