[译]Kotlin中的龟(List)兔(Sequence)赛跑

谁借莪１个温暖的怀抱￠ 2022-05-21 20:49 182阅读 0赞

**翻译说明:**

**原标题: Kotlin : Slow List and Lazy Sequence**

**原文地址: [https://medium.com/@elye.project/kotlin-slow-list-and-lazy-sequence-61691fc974c5][https_medium.com_elye.project_kotlin-slow-list-and-lazy-sequence-61691fc974c5]**

**原文作者: [Elye][]**

自从Kotlin可以兼容Java7上后，很高兴的是我们可以轻松地在List上使用各种集合操作符并且可以链式调用它们。但是我们知道在某些情况下使用List的迭代器并不是最好的方式，那么还有另一种方式就是使用**序列(sequence)**

### 没有背景只能辛苦工作的List列表 ###

在我们了解序列在某些情况下为什么更好之前，让我告诉你一些关于List的内容。

List内部使用Iterator进行操作。这是一个非常勤奋的群体，我链式调用它的每一个操作，它都能确保没有任何遗漏的完成。

val list = listOf(1, 2, 3, 4, 5, 6)
    list.map{
         it * 2 }.filter {
         it % 3  == 0 }.average()

![1641859c9ec09c69_w_800_h_474_f_png_s_106034][]

正如你在上面的插图中看到的，对于每一步操作，List的每个元素都需要被处理。

为了证明这一点，让我们输出一些log日志:

val list = listOf(1, 2, 3, 4, 5, 6)
    val result = list
            .map{
         println("In Map"); it * 2 }
            .filter {
         println("In Filter");it % 3  == 0 }
    println("Before Average")
    println(result.average())

结果如下:

In Map
    In Map
    In Map
    In Map
    In Map
    In Map
    In Filter
    In Filter
    In Filter
    In Filter
    In Filter
    In Filter
    Before Average
    9.0

很棒。勤奋努力地工作，并完成所有的过程。

### 懒惰的家伙，Sequence序列… ###

好的，现在让我们通过调用asSequence()扩展函数来将List转化成一个序列(Sequence)。

val list = listOf(1, 2, 3, 4, 5, 6)
    val result = list.asSequence()
            .map{
         println("In Map"); it * 2 }
            .filter {
         println("In Filter");it % 3  == 0 }
    println("Before Average")
    println(result.average())

结果如下:

Before Average
    In Map
    In Filter
    In Map
    In Filter
    In Map
    In Filter
    In Map
    In Filter
    In Map
    In Filter
    In Map
    In Filter
    9.0

哇，有趣…,注意到 **“Before Average”** 是最先输出的，换句话说，如果我不调用 **average()** 函数，那么序列(sequence)就没有做任何操作。

它很懒，不想做任何工作，直到终端连接到它。终端就像是一种操作，实际上就是一个操作符扩展函数，会返回其他类型结果(除了Sequence<T>之外),例如 **sum()，average()，first()等…。甚至toList()用于将Sequence转换为List**

除此之外，你会注意到它输出的**In Map**和**In Filter**交叉出现。这意味着它会在通过链条之前一个接一个地通过链条，直到它通过终端，即平均操作，然后通过下一个元素。

![164186b9df264a42_w_800_h_475_f_png_s_113751][]

### 那么，序列Sequence到底有什么好处呢？ ###

如果你这样想，想象你想要拿到集合变换后的第一个元素。

#### 让我们看下List处理方式: ####

val list = listOf(1, 2, 3, 4, 5, 6)
    val result = list
            .map{
         println("In Map $it"); it * 2 }
            .filter {
         println("In Filter $it");it % 3  == 0 }
    println(result.first())

结果如下:

In Map 1
    In Map 2
    In Map 3
    In Map 4
    In Map 5
    In Map 6
    In Filter 2
    In Filter 4
    In Filter 6
    In Filter 8
    In Filter 10
    In Filter 12
    6

所有在一起总共13行，这意味着13次操作。

#### 让我们看下Sequence处理方式: ####

val sequence = sequenceOf(1, 2, 3, 4, 5, 6)
    val result = sequence
            .map{
         println("In Map $it"); it * 2 }
            .filter {
         println("In Filter $it");it % 3  == 0 }
    println(result.first())

结果是:

In Filter 2
    In Map 2
    In Filter 4
    In Map 3
    In Filter 6
    6

仅仅7行即7次操作。这意味着它只要找到第一个元素的那一刻，就会终止整个过程。

你可以想像，这会加快整个运行的过程。

### 加速仅仅只适用于first()操作吗？ ###

让我们做一些试验。

#### 试验Map操作 ####

val sequence = generateSequence(1) {
         it + 1 }.take(50000000)
    val list = sequence.toList()
    
    println("List Map Sum= " 
            + measureNanoTime {
         list.map {
         it * 2 }.sum() })
    println("Sequence Map Sum " 
            + measureNanoTime {
         sequence.map {
         it * 2 }.sum() })
    
    println("List Map Average " 
            + measureNanoTime {
         list.map {
         it * 2 }.average() })
    println("Sequence Map Average " 
            + measureNanoTime {
         sequence.map {
         it * 2 }.average() })

结果是:

List Map Sum 14727907362
    Sequence Map Sum 2074397969
    List Map Average 11460520785
    Sequence Map Average 3268960487

*  List: 在**Map:Sum**操作上花费了14.7s，在**Map:Average**操作上花费了11.5s
 *  Sequence: 在**Map:Sum**操作上花费了2.1s, 在**Map:Average**操作上花费了3.3s

![1641875b156ee0aa_w_400_h_291_f_jpeg_s_35428][]

看上去像前面的有一个Map操作时，Sequence的性能会比List更快。也许它不需要像List那样存储map操作后的中间结果，从而会更快。

#### 试验Filter操作 ####

val sequence = generateSequence(1) {
         it + 1 }.take(50000000)
    val list = sequence.toList()
    
    println("List Filter Sum " 
            + measureNanoTime {
         list.filter {
         it % 3 == 0 }.sum() })
    println("Sequence Filter Sum " 
            + measureNanoTime {
         sequence.filter {
         it % 3 == 0 }.sum() })
    
    println("List Filter Average " 
            + measureNanoTime {
         list.filter {
         it % 3 == 0 }.average() })
    println("Sequence Filter Average " 
            + measureNanoTime {
         sequence.filter {
         it % 3 == 0 }.average() })

结果是:

List Filter Sum 506351694
    Sequence Filter Sum 873175271
    List Filter Average 391790033
    Sequence Filter Average 838510968

*  List: 在**Filter:Sum**操作上花费了0.5s，在**Filter:Average**操作上花费了0.4s
 *  Sequence: 在**Filter:Sum**操作上花费了0.9s, 在**Filter:Average**操作上花费了0.8s

![164187cd6d1ca211_w_550_h_344_f_jpeg_s_43662][]

对于前面的Filter操作，Sequence比List更慢。 深入了解函数，看起来像Sequence的Filter操作需要有更多的开销来检查某些状态，而List的Filter则是一个简单的检查并收集新的元素。

### 试验Map和Filter操作 ###

val sequence = generateSequence(1) {
         it + 1 }.take(50000000)
    val list = sequence.toList()
    
    println("List Map Filter Sum\t\t " + measureNanoTime {
         
        list.map {
         it * 2 }.filter {
         it % 3 == 0 }.sum() })
    println("Sequence Map Filter Sum\t " + measureNanoTime {
         
        sequence.map {
         it * 2 }.filter {
         it % 3 == 0 }.sum() })
    
    println("List Map Filter Average\t\t " + measureNanoTime {
         
        list.map {
         it * 2 }.filter {
         it % 3 == 0 }.average() })
    println("Sequence Map Filter Average\t " + measureNanoTime {
         
        sequence.map {
         it * 2 }.filter {
         it % 3 == 0 }.average() })

结果是:

List Map Filter Sum 34845242323
    Sequence Map Filter Sum 2820436086
    List Map Filter Average 2328258876
    Sequence Map Filter Average 18618444560

*  List: 在**Map:Filter:Sum**操作上花费了34.8s，在**Map:Filter:Average**操作上花费了2.3s
 *  Sequence: 在**Map:Filter:Sum**操作上花费了2.8s, 在**Map:Filter:Average**操作上花费了18.6s

![164188283852f489_w_320_h_239_f_jpeg_s_21228][]

一个相对令人惊讶的结果，如Map:Filter:Sum，Sequence比List快得多，而Map:Filter:Average，List比Sequence要快得多。

#### 试验直接使用Sequence和List ####

val sequence = generateSequence(1) {
         it + 1 }.take(50000000)
    val list = sequence.toList()
    
    println("List Sum " + measureNanoTime {
         list.sum() })
    println("Sequence Sum " + measureNanoTime {
         sequence.sum() })
    
    println("List Average " + measureNanoTime {
         list.average() })
    println("Sequence Average " + measureNanoTime {
         sequence.average() })

结果是:

List Sum 91726022
    Sequence Sum 592771887
    List Average 101141460
    Sequence Average 622616340

*  List: 在**Sum**操作上花费了0.1s，在**Average**操作上花费了0.1s
 *  Sequence: 在**Sum**操作上花费了0.5s, 在**Average**操作上花费了0.6s

没有任何中间操作，明显列表List比序列Sequence要快。

### 总结: ###

*  1、当不需要中间操作时，使用List
 *  2、当仅仅只有map操作时，使用sequence
 *  3、当仅仅只有filter操作时，使用List
 *  4、如果末端操作是first时，使用sequence
 *  5、对于没有提及的其他操作符或者其他操作符的组合，请尝试使用例子去验证一下

### 译者有话说: ###

首先，说下为什么要翻译这篇博客？关于Kotlin中的Sequence和List的使用以及源码解析相关的文章我已经写过两篇了，这篇博客主要吸引我的一点就是以更多运行的例子试验和相关幽默的配图更加形象地描述了Sequence，List的区别以及各自的使用场景。

然而，这篇博客并没有深入源码去讲解Sequence的实现，这篇之前写的博客 **[浅谈Kotlin中的序列(Sequences)源码完全解析(十)][Kotlin_Sequences]** 从源码角度带你一步步分析Sequence序列背后的原理，关于如何正确使用Sequence和List以及各自使用场景,之前翻译的一篇博客 **[\[译\]Kotlin中是应该使用序列(Sequences)还是集合(Lists)?][Kotlin_Sequences_Lists]** 会有更加全面的介绍。

最后，有了这三篇文章应该更加全面理解了Sequence的原理和使用。

![1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536][]

**欢迎关注Kotlin开发者联盟，这里有最新Kotlin技术文章，每周会不定期翻译一篇Kotlin国外技术文章。如果你也喜欢Kotlin，欢迎加入我们~~~**

### Kotlin系列文章，欢迎查看: ###

> Kotlin邂逅设计模式系列:

*  **[当Kotlin完美邂逅设计模式之单例模式(一)][Kotlin]**

> 数据结构与算法系列:

*  **[每周一算法之二分查找(Kotlin描述)][Kotlin 1]**

> 翻译系列：

*  **[\[译\] Kotlin中关于Companion Object的那些事][Kotlin_Companion Object]**
 *  **[\[译\]记一次Kotlin官方文档翻译的PR(内联类)][Kotlin_PR]**
 *  **[\[译\]Kotlin中内联类的自动装箱和高性能探索(二)][Kotlin 2]**
 *  **[\[译\]Kotlin中内联类(inline class)完全解析(一)][Kotlin_inline class]**
 *  **[\[译\]Kotlin的独门秘籍Reified实化类型参数(上篇)][Kotlin_Reified]**
 *  **[\[译\]Kotlin泛型中何时该用类型形参约束?][Kotlin 3]**
 *  **[\[译\] 一个简单方式教你记住Kotlin的形参和实参][_Kotlin]**
 *  **[\[译\]Kotlin中是应该定义函数还是定义属性?][Kotlin 4]**
 *  **[\[译\]如何在你的Kotlin代码中移除所有的!!(非空断言)][Kotlin 5]**
 *  **[\[译\]掌握Kotlin中的标准库函数: run、with、let、also和apply][Kotlin_ run_with_let_also_apply]**
 *  **[\[译\]有关Kotlin类型别名(typealias)你需要知道的一切][Kotlin_typealias]**
 *  **[\[译\]Kotlin中是应该使用序列(Sequences)还是集合(Lists)?][Kotlin_Sequences_Lists 1]**
 *  **[\[译\]Kotlin中的龟(List)兔(Sequence)赛跑][Kotlin_List_Sequence]**

> 原创系列：

*  **[教你如何完全解析Kotlin中的类型系统][Kotlin 6]**
 *  **[如何让你的回调更具Kotlin风味][Kotlin 7]**
 *  **[Jetbrains开发者日见闻(三)之Kotlin1.3新特性(inline class篇)][Jetbrains_Kotlin1.3_inline class]**
 *  **[JetBrains开发者日见闻(二)之Kotlin1.3的新特性(Contract契约与协程篇)][JetBrains_Kotlin1.3_Contract]**
 *  **[JetBrains开发者日见闻(一)之Kotlin/Native 尝鲜篇][JetBrains_Kotlin_Native]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(实践篇)][Kotlin 8]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(下篇)][Kotlin 9]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(上篇)][Kotlin 10]**
 *  **[Kotlin的独门秘籍Reified实化类型参数(下篇)][Kotlin_Reified 1]**
 *  **[有关Kotlin属性代理你需要知道的一切][Kotlin 11]**
 *  **[浅谈Kotlin中的Sequences源码解析][Kotlin_Sequences 1]**
 *  **[浅谈Kotlin中集合和函数式API完全解析-上篇][Kotlin_API_-]**
 *  **[浅谈Kotlin语法篇之lambda编译成字节码过程完全解析][Kotlin_lambda]**
 *  **[浅谈Kotlin语法篇之Lambda表达式完全解析][Kotlin_Lambda]**
 *  **[浅谈Kotlin语法篇之扩展函数][Kotlin 12]**
 *  **[浅谈Kotlin语法篇之顶层函数、中缀调用、解构声明][Kotlin 13]**
 *  **[浅谈Kotlin语法篇之如何让函数更好地调用][Kotlin 14]**
 *  **[浅谈Kotlin语法篇之变量和常量][Kotlin 15]**
 *  **[浅谈Kotlin语法篇之基础语法][Kotlin 16]**

> Effective Kotlin翻译系列

*  **[\[译\]Effective Kotlin系列之考虑使用原始类型的数组优化性能(五)][Effective Kotlin]**
 *  **[\[译\]Effective Kotlin系列之使用Sequence来优化集合的操作(四)][Effective Kotlin_Sequence]**
 *  **[\[译\]Effective Kotlin系列之探索高阶函数中inline修饰符(三)][Effective Kotlin_inline]**
 *  **[\[译\]Effective Kotlin系列之遇到多个构造器参数要考虑使用构建器(二)][Effective Kotlin 1]**
 *  **[\[译\]Effective Kotlin系列之考虑使用静态工厂方法替代构造器(一)][Effective Kotlin 2]**

> 实战系列:

*  **[用Kotlin撸一个图片压缩插件ImageSlimming-导学篇(一)][Kotlin_ImageSlimming-]**
 *  **[用Kotlin撸一个图片压缩插件-插件基础篇(二)][Kotlin_-]**
 *  **[用Kotlin撸一个图片压缩插件-实战篇(三)][Kotlin_- 1]**
 *  **[浅谈Kotlin实战篇之自定义View图片圆角简单应用][Kotlin_View]**

[https_medium.com_elye.project_kotlin-slow-list-and-lazy-sequence-61691fc974c5]: https://medium.com/@elye.project/kotlin-slow-list-and-lazy-sequence-61691fc974c5
[Elye]: https://medium.com/@elye.project?source=post_header_lockup
[1641859c9ec09c69_w_800_h_474_f_png_s_106034]: https://user-gold-cdn.xitu.io/2018/6/19/1641859c9ec09c69?w=800&h=474&f=png&s=106034
[164186b9df264a42_w_800_h_475_f_png_s_113751]: https://user-gold-cdn.xitu.io/2018/6/19/164186b9df264a42?w=800&h=475&f=png&s=113751
[1641875b156ee0aa_w_400_h_291_f_jpeg_s_35428]: https://user-gold-cdn.xitu.io/2018/6/19/1641875b156ee0aa?w=400&h=291&f=jpeg&s=35428
[164187cd6d1ca211_w_550_h_344_f_jpeg_s_43662]: https://user-gold-cdn.xitu.io/2018/6/19/164187cd6d1ca211?w=550&h=344&f=jpeg&s=43662
[164188283852f489_w_320_h_239_f_jpeg_s_21228]: https://user-gold-cdn.xitu.io/2018/6/19/164188283852f489?w=320&h=239&f=jpeg&s=21228
[Kotlin_Sequences]: https://juejin.im/post/5b1b3cbbf265da6e225cec67
[Kotlin_Sequences_Lists]: https://juejin.im/post/5b13fdace51d450696590828
[1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536]: https://user-gold-cdn.xitu.io/2018/5/14/1635c3fb0ba21ec1?w=430&h=430&f=jpeg&s=39536
[Kotlin]: https://blog.csdn.net/u013064109/article/details/89078666
[Kotlin 1]: https://blog.csdn.net/u013064109/article/details/89023937
[Kotlin_Companion Object]: https://blog.csdn.net/u013064109/article/details/89199478
[Kotlin_PR]: https://blog.csdn.net/u013064109/article/details/85180755
[Kotlin 2]: https://blog.csdn.net/u013064109/article/details/84899657
[Kotlin_inline class]: https://blog.csdn.net/u013064109/article/details/84866092
[Kotlin_Reified]: https://blog.csdn.net/u013064109/article/details/83388976
[Kotlin 3]: https://blog.csdn.net/u013064109/article/details/83120352
[_Kotlin]: https://blog.csdn.net/u013064109/article/details/83099581
[Kotlin 4]: https://blog.csdn.net/u013064109/article/details/80344848
[Kotlin 5]: https://blog.csdn.net/u013064109/article/details/80358822
[Kotlin_ run_with_let_also_apply]: https://blog.csdn.net/u013064109/article/details/80387322
[Kotlin_typealias]: https://blog.csdn.net/u013064109/article/details/80444565
[Kotlin_Sequences_Lists 1]: https://blog.csdn.net/u013064109/article/details/80562009
[Kotlin_List_Sequence]: https://blog.csdn.net/u013064109/article/details/80740230
[Kotlin 6]: https://blog.csdn.net/u013064109/article/details/88985474
[Kotlin 7]: https://blog.csdn.net/u013064109/article/details/86695094
[Jetbrains_Kotlin1.3_inline class]: https://blog.csdn.net/u013064109/article/details/84837918
[JetBrains_Kotlin1.3_Contract]: https://blog.csdn.net/u013064109/article/details/84782206
[JetBrains_Kotlin_Native]: https://blog.csdn.net/u013064109/article/details/84729814
[Kotlin 8]: https://blog.csdn.net/u013064109/article/details/84504847
[Kotlin 9]: https://blog.csdn.net/u013064109/article/details/84060626
[Kotlin 10]: https://blog.csdn.net/u013064109/article/details/83869716
[Kotlin_Reified 1]: https://blog.csdn.net/u013064109/article/details/83507076
[Kotlin 11]: https://blog.csdn.net/u013064109/article/details/82794410
[Kotlin_Sequences 1]: https://blog.csdn.net/u013064109/article/details/80588034
[Kotlin_API_-]: https://blog.csdn.net/u013064109/article/details/80275942
[Kotlin_lambda]: https://blog.csdn.net/u013064109/article/details/80139556
[Kotlin_Lambda]: https://blog.csdn.net/u013064109/article/details/80088158
[Kotlin 12]: https://blog.csdn.net/u013064109/article/details/79968846
[Kotlin 13]: https://blog.csdn.net/u013064109/article/details/79887528
[Kotlin 14]: https://blog.csdn.net/u013064109/article/details/79503709
[Kotlin 15]: https://blog.csdn.net/u013064109/article/details/79296502
[Kotlin 16]: https://blog.csdn.net/u013064109/article/details/77843579
[Effective Kotlin]: https://blog.csdn.net/u013064109/article/details/84996951
[Effective Kotlin_Sequence]: https://blog.csdn.net/u013064109/article/details/84981570
[Effective Kotlin_inline]: https://blog.csdn.net/u013064109/article/details/84948769
[Effective Kotlin 1]: https://blog.csdn.net/u013064109/article/details/82121020
[Effective Kotlin 2]: https://blog.csdn.net/u013064109/article/details/81916446
[Kotlin_ImageSlimming-]: https://blog.csdn.net/u013064109/article/details/80850992
[Kotlin_-]: https://blog.csdn.net/u013064109/article/details/80879296
[Kotlin_- 1]: https://blog.csdn.net/u013064109/article/details/81814643
[Kotlin_View]: https://blog.csdn.net/u013064109/article/details/80102036