Sequence序列

Sequence 是Kotlin標(biāo)準(zhǔn)庫提供的一種容器類型。它和Iterable一樣具備對集合進(jìn)行多步驟操作能力，但是卻是采用了一種完全不同于Iterable的實(shí)現(xiàn)方式：

val map = (0..3).filter {
    println("filter:$it")
    it % 2 == 0
}.map {
    println("map:$it")
    it + 1
}
println(map)

上面的代碼用來演示Iterable進(jìn)行連續(xù)操作的情況。它的輸出如下：

filter:0
filter:1
filter:2
filter:3
map:0
map:2
[1, 3]

像map和filter這些鏈?zhǔn)郊虾瘮?shù)它們都會立即執(zhí)行并創(chuàng)建中間臨時集用來保存數(shù)據(jù)。當(dāng)原始數(shù)據(jù)不多時，這并不會有什么影響。但是，當(dāng)原始數(shù)據(jù)量非常大的時候。這就會變的非常低效。而此時，就可以借助Sequence提高效率。

val sequence = (0..3).asSequence().filter {
    println("filter:$it")
    it % 2 == 0
}.map {
    println("map:$it")
    it + 1
}
println("準(zhǔn)備開始執(zhí)行")
println(sequence.toList())

上面的代碼執(zhí)行結(jié)果如下：

準(zhǔn)備開始執(zhí)行
filter:0
map:0
filter:1
filter:2
map:2
filter:3
[1, 3]

對比Iterable和Sequence：

Iterable是即時的、Sequence是惰性的：前者會要求盡早的計(jì)算結(jié)果，因此在多步驟處理鏈的每一環(huán)都會有中間產(chǎn)物也就是新的集合產(chǎn)生；后者會盡可能的延遲計(jì)算結(jié)果，Sequence處理的中間函數(shù)不進(jìn)行任何計(jì)算。相反，他們返回一個新Sequence的，用新的操作裝飾前一個，所有的這些計(jì)算都只是在類似toList的終端操作期間進(jìn)行。

區(qū)分中間操作符和末端操作符的方式也很簡單：如果操作符返回的是一個Sequence類型的數(shù)據(jù)，它就是中間操作符。

在操作的執(zhí)行方式上也有所不同：Iterable每次都是在整個集合執(zhí)行完操作后再進(jìn)行下一步操作——采用第一個操作并將其應(yīng)用于整個集合，然后移動到下一個操作，官方將其稱呼為急切式或者按步驟執(zhí)行（Eager/step-by-step）；**而Sequence則是逐個對每個元素執(zhí)行所有操作。是一種惰性順序——取第一個元素并應(yīng)用所有操作，然后取下一個元素，依此類推。**官方將其稱呼為惰性式或者按元素執(zhí)行（Lazy/element-by-element)

序列的惰性會帶來一下幾個優(yōu)點(diǎn)：

• 它們的操作按照元素的自然順序進(jìn)行；
• 只做最少的操作；
• 元素可以是無限多個；
• 不需要在每一步都創(chuàng)建集合

Sequence可避免生成中間步驟的結(jié)果，從而提高了整個集合處理鏈的性能。但是，惰性性質(zhì)也會帶來一些運(yùn)行開銷。所以在使用時要權(quán)衡惰性開銷和中間步驟開銷，在Sequence和Iterable中選擇更加合適的實(shí)現(xiàn)方式。

執(zhí)行的順序

sequenceOf(1,2,3)
    .filter { print("F$it, "); it % 2 == 1 }
    .map { print("M$it, "); it * 2 }
    .forEach { print("E$it, ") } 
// Prints: F1, M1, E2, F2, F3, M3, E6,
listOf(1,2,3)
    .filter { print("F$it, "); it % 2 == 1 }
    .map { print("M$it, "); it * 2 }
    .forEach { print("E$it, ") }
// Prints: F1, F2, F3, M1, M3, E2, E6,

sequence的執(zhí)行時按照元素進(jìn)行的，依次對元素執(zhí)行所有的操作，對一個元素而言，所有操作時依次全部執(zhí)行的。而普通集合操作則是以操作步驟進(jìn)行的，當(dāng)所有的元素執(zhí)行完當(dāng)前操作后才會進(jìn)入下一個操作。

只做最少的操作

試想一下我們有一千萬個數(shù)字，我們要經(jīng)過幾次變換取出20個，使用下面的代碼對比一下序列和不同集合操作的性能：

fun main(){
    val fFlow = FFlow()
    fFlow.demoList()
    fFlow.demoSequence()
}
fun demoSequence() {
    val currentTimeMillis = System.currentTimeMillis()
    val list =
    (0..10000000).asSequence().map { it * 2 }.map { it - 1 }.take(20).toList()
    println("demoSequence:${System.currentTimeMillis() - currentTimeMillis}：$list")
}
fun demoList() {
    val currentTimeMillis = System.currentTimeMillis()
    val list =
    (0..10000000).map { it * 2 }.map { it - 1 }.take(20).toList()
    println("demoList:${System.currentTimeMillis() - currentTimeMillis}：$list")
}

輸出的結(jié)果如下：

demoSequence:20ms：[-1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37]
demoList:4106ms：[-1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37]

這就是只執(zhí)行最少操作的意思，序列按照元素順序執(zhí)行，當(dāng)取夠29個元素之后便會立即停止計(jì)算。而不同的集合則不同，沒有中間操作的概念。它的每次操作都會對整個數(shù)組中的所有元素執(zhí)行完才會進(jìn)行下一個——也就是前兩個map都要執(zhí)行一千萬次。

序列可以是無限的

看如下代碼：

var list = emptyArray<Int>()
var  i = 0
while(true){
    list[i] = i++
}
list.take(10)

很明顯，這段代碼是沒法正常運(yùn)行的，因?yàn)檫@里有一個死循環(huán)。我們也無法創(chuàng)建一個無限長度的集合。但是：因?yàn)樾蛄惺桨床襟E依照需求進(jìn)行處理的，所喲我們可以創(chuàng)建無限序列：

val noEnd = sequence {
    var i = 1
    while (true) {
        yield(i)
        i *= 2
    }
}
noEnd.take(4).toList()
//輸出:[1, 2, 4, 8]

但是一定要注意，我們雖然可以這么寫，但是務(wù)必不能真的讓while一直循環(huán)。我們不能直接使用toList。必須提供一個能結(jié)束循環(huán)的操作符，也就是不能取出所有元素（無限個）——要么使用類似take的操作來限制它們的數(shù)量，要么使用不需要所有元素的終端操作，例如first, find, any, all, indexOf等。

序列不會在每個步驟創(chuàng)建集合

普通的集合會在每次變換之后都會創(chuàng)建新的集合取存儲所有變換后的元素。而每次創(chuàng)建集合和填入數(shù)據(jù)都會帶來不小的性能開銷。尤其是當(dāng)我們處理大量或大量的集合時，性能問題會愈發(fā)凸顯。而序列的按元素操作，則不會有這個問題。除非手動調(diào)用了終端操作符，否則不會生成新的集合。

Sequence的基本使用

Sequence序列的使用和普通的Iterable極其相似，實(shí)際上其內(nèi)部也還是借助Iterable實(shí)現(xiàn)的。在研究它的內(nèi)部實(shí)現(xiàn)原理之前，想從Sequence的創(chuàng)建和基本的序列操作來演示Sequence的基本用法。

序列的創(chuàng)建

創(chuàng)建Sequence的方式大概可以分為。分別是由元素創(chuàng)建、通過Iterable、借助函數(shù)以及由代碼塊創(chuàng)建。

由元素創(chuàng)建：通過調(diào)用頂級函數(shù)sequenceOf實(shí)現(xiàn)：

val ints = sequenceOf(1, 2, 3, 4, 5, 6, 7)
val strings = sequenceOf("a","b","c","d","e")

通過Iterable轉(zhuǎn)化：借助Iterable的擴(kuò)展函數(shù)asSequence實(shí)現(xiàn)：

val ints = listOf(1, 2, 3, 4, 5, 6, 7).asSequence()
val strings = listOf("a","b","c","d","e").asSequence()

通過generateSequence實(shí)現(xiàn)：該方法有三個：

generateSequence(seedFunction: () -> T?, nextFunction: (T) -> T?): Sequence<T> 
generateSequence(seed: T?, nextFunction: (T) -> T?): Sequence<T>
generateSequence(nextFunction: () -> T?): Sequence<T> 

最終都是通過GeneratorSequence實(shí)現(xiàn)的，這里先不進(jìn)行源碼分析。只討論使用方式：

• 其中三個函數(shù)都有的形參nextFunction可以理解為元素生成器，序列里的元素都通過調(diào)用該函數(shù)生成，當(dāng)它返回為null是，序列停止生成（所以，nextFunction必須要在某個情況下返回null，否則會因?yàn)樾蛄性厥菬o限多個觸發(fā)java.lang.OutOfMemoryError: Java heap space異常）。
• 而另外兩個的seedFunction和seed形參都是為了確定數(shù)據(jù)初始值的。區(qū)別在于一個直接指明，一個通過調(diào)用函數(shù)獲取。

分別用這三個函數(shù)生成0~100的序列，代碼如下：

val generateSequenceOne = generateSequence {
    if (i < 100) {
        i++
    } else {
        null
    }
}
val generateSequenceTwo = generateSequence(0) {
    if (it < 100) {
        it+1//此處的it是上一個元素
    } else {
        null
    }
}
val generateSequenceThree = generateSequence({ 0 }) {
    if (it < 100) {
        it+1//此處的it是上一個元素
    } else {
        null
    }
}

由代碼塊生成：借助sequence(block: suspend SequenceScope.() -> Unit)函數(shù)。該函數(shù)接受一個掛起函數(shù)，該函數(shù)會接受一個SequenceScope實(shí)例，這個實(shí)例無需我們創(chuàng)建（后面源碼分析會講到）。SequenceScope提供了yield和yieldAll方法復(fù)雜返回序列元素給調(diào)用者，并暫停序列的執(zhí)行，直到使用者請求下一個元素。

用該函數(shù)生成0~100的序列，代碼如下：

val ints = sequence {
    repeat(100) {
        yield(it)
    }
}

序列的操作

對序列的操作可以分為中間操作和末端操作兩種。它們只要有一下另種區(qū)別：

• 中間操作返回惰性生成的一個新的序列，而末端序列則為其他普通的數(shù)據(jù)類型；
• 中間操作不會立刻執(zhí)行代碼，僅當(dāng)執(zhí)行了末端操作序列才會開始執(zhí)行。

常見的中間操作包括：map、fliter、first、last、take等；它們會序列提供數(shù)據(jù)變化過濾等增強(qiáng)功能基本上和kotlin提供的集合操作符有著相同的功能。

常見的末端操作有：toList、toMutableList、sum、count等。它們在提供序列操作功能的同時，還會觸發(fā)序列的運(yùn)行。

Sequence源碼分析

上文對序列做了簡單的入門介紹。接下來深入源碼去了解一下Sequence的實(shí)現(xiàn)方式。

Sequence是什么？

Kotlin對的定義Sequence很簡單：

public interface Sequence <out T> {
    public operator fun iterator(): Iterator<T>
}

就是一個接口，定義了一個返回Iterator的方法。接口本身只定義了Sequence具有返回一個迭代器的能力。具體的功能實(shí)現(xiàn)還是靠它的實(shí)現(xiàn)類完成。

可以概括一些：序列就是一個具備提供了迭代器能力的類。

序列的創(chuàng)建方式分析

結(jié)合上文中提到的序列的四種創(chuàng)建方式，我們依次分析一下它的創(chuàng)建流程。

我們首先以比較常用的通過Iterable轉(zhuǎn)化獲取序列，它需要借助asSequence方法分析一下，使用listOf("a","b","c","d","e").asSequence()生成一個序列。調(diào)用鏈如下：

public fun <T> Iterable<T>.asSequence(): Sequence<T> {
    return Sequence { this.iterator() }
}
public inline fun <T> Sequence(crossinline iterator: () -> Iterator<T>): Sequence<T> = object : Sequence<T> {
    override fun iterator(): Iterator<T> = iterator()
}

流程很簡單，一個擴(kuò)展函數(shù)加一個內(nèi)聯(lián)函數(shù)。最終通過匿名內(nèi)部類的方式創(chuàng)建一個Sequence并返回。代碼很好理解，實(shí)際上它的實(shí)現(xiàn)邏輯等同于下面的代碼：

val sequence = MySequence(listOf("a","b","c","d","e").iterator())
class MySequence<T>(private val iterator:Iterator<T>):Sequence<T>{
    override fun iterator(): Iterator<T> {
        return iterator
    }
}

接著看一下通過調(diào)用頂級函數(shù)sequenceOf實(shí)現(xiàn)，以sequenceOf("a","b","c","d","e")為例，它的調(diào)用邏輯如下：

public fun <T> sequenceOf(vararg elements: T): Sequence<T> = if (elements.isEmpty()) emptySequence() else elements.asSequence()

可以看到依舊是借助asSequence實(shí)現(xiàn)的。

接下來看一下代碼塊和generateSequence的實(shí)現(xiàn)方式，這兩個方式會比較復(fù)雜一點(diǎn)，畢竟前面兩個都是借助List進(jìn)行轉(zhuǎn)換，而List本身就能提供迭代器Iterator。后面兩個明顯需要提供新的迭代器。 首先看一下代碼看的實(shí)現(xiàn)方式：

val ints = sequence {
        repeat(100) {
            yield(it)
        }
    }

其中sequence的調(diào)用邏輯如下：

public fun <T> sequence(@BuilderInference block: suspend SequenceScope<T>.() -> Unit): Sequence<T> = Sequence { iterator(block) }
public fun <T> iterator(@BuilderInference block: suspend SequenceScope<T>.() -> Unit): Iterator<T> {
    //創(chuàng)建迭代器
    val iterator = SequenceBuilderIterator<T>()
    iterator.nextStep = block.createCoroutineUnintercepted(receiver = iterator, completion = iterator)
    return iterator
}
public inline fun <T> Sequence(crossinline iterator: () -> Iterator<T>): Sequence<T> = object : Sequence<T> {
    override fun iterator(): Iterator<T> = iterator()
}

可以發(fā)現(xiàn)：該方法和asSequence一樣最終也是通過匿名內(nèi)部類的方式創(chuàng)建了一個Sequence。不過區(qū)別在于，該方法需要創(chuàng)建一個新的迭代器，也就是SequenceBuilderIterator 。同樣以MySequence為例，它的創(chuàng)建流程等同于一下代碼：

fun mian(){
    create<Int> { myblock() }
}
suspend fun  SequenceScope<Int>.myblock(){
    repeat(100) {
        yield(it)
    }
}
fun <Int> create(block: suspend SequenceScope<Int>.() -> Unit):Sequence<Int>{
    val iterator = SequenceBuilderIterator<Int>()
    iterator.nextStep = block.createCoroutineUnintercepted(receiver = iterator, completion = iterator)
    return MySequence(iterator)
}

當(dāng)然，這是不可能實(shí)現(xiàn)的，因?yàn)镾equenceBuilderIterator是被private修飾了，我們是無法直接訪問的。這里強(qiáng)制寫出來演示一下它的流程。

最后看一下通過generateSequence方法創(chuàng)建序列的源碼，一共有三個：

public fun <T : Any> generateSequence(seedFunction: () -> T?, nextFunction: (T) -> T?): Sequence<T> =
    GeneratorSequence(seedFunction, nextFunction)
public fun <T : Any> generateSequence(seed: T?, nextFunction: (T) -> T?): Sequence<T> =
    if (seed == null)
        EmptySequence
    else
        GeneratorSequence({ seed }, nextFunction)
public fun <T : Any> generateSequence(nextFunction: () -> T?): Sequence<T> {
    return GeneratorSequence(nextFunction, { nextFunction() }).constrainOnce()
}

最終都是創(chuàng)建了GeneratorSequence的一個實(shí)例并返回，而GeneratorSequence實(shí)現(xiàn)了Sequence接口并重寫了iterator()方法：

private class GeneratorSequence<T : Any>(private val getInitialValue: () -> T?, private val getNextValue: (T) -> T?) : Sequence<T> {
    override fun iterator(): Iterator<T> = object : Iterator<T> {
        var nextItem: T? = null
        var nextState: Int = -2 // -2 for initial unknown, -1 for next unknown, 0 for done, 1 for continue
        private fun calcNext() {
            nextItem = if (nextState == -2) getInitialValue() else getNextValue(nextItem!!)
            nextState = if (nextItem == null) 0 else 1
        }
        override fun next(): T {
            if (nextState < 0)
                calcNext()
            if (nextState == 0)
                throw NoSuchElementException()
            val result = nextItem as T
            // Do not clean nextItem (to avoid keeping reference on yielded instance) -- need to keep state for getNextValue
            nextState = -1
            return result
        }
        override fun hasNext(): Boolean {
            if (nextState < 0)
                calcNext()
            return nextState == 1
        }
    }
}

總結(jié)一下Sequence的創(chuàng)建大致可以分為三類：

• 使用List自帶的迭代器通過匿名的方式創(chuàng)建Sequence實(shí)例，sequenceOf("a","b","c","d","e")和listOf("a","b","c","d","e").asSequence()就是這種方式；
• 創(chuàng)建新的SequenceBuilderIterator迭代器，并通過匿名的方式創(chuàng)建Sequence實(shí)例。例如使用代碼塊的創(chuàng)建方式。
• 創(chuàng)建GeneratorSequence，通過重寫iterator()方法，使用匿名的方式創(chuàng)建Iterator。GeneratorSequence方法就是采用的這種方式。

看完創(chuàng)建方式，也沒什么奇特的，就是一個提供迭代器的普通類。還是看不出是如何惰性執(zhí)行操作的。接下來就分析一下惰性操作的原理。

序列的惰性原理

以最常用的map操作符為例：普通的集合操作源碼如下：

public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
	//出啊年一個新的ArrayList，并調(diào)用mapTo方法
    return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}
public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C {
	//遍歷原始的集合，進(jìn)行變換操作，然后將變換后的數(shù)據(jù)依次加入到新創(chuàng)建的集合
    for (item in this)
        destination.add(transform(item))
    //返回新集合    
    return destination
}

可以看到：當(dāng)List.map被調(diào)用后，便會立即創(chuàng)建新的集合，然后遍歷老數(shù)據(jù)并進(jìn)行變換操作。最后返回一個新的數(shù)據(jù)。這印證了上面提到的普通集合的操作時按照步驟且會立刻執(zhí)行的理論。

接下來看一下序列的map方法，它的源碼如下：

public fun <T, R> Sequence<T>.map(transform: (T) -> R): Sequence<R> {
    return TransformingSequence(this, transform)
}
internal class TransformingSequence<T, R>
constructor(private val sequence: Sequence<T>, private val transformer: (T) -> R) : Sequence<R> {
    override fun iterator(): Iterator<R> = object : Iterator<R> {
    	  //注釋一：TransformingSequence的iterator持有上一個序列的迭代器
        val iterator = sequence.iterator()
        override fun next(): R {
        	//注釋二：在開始執(zhí)行迭代時，向上調(diào)用前一個序列的迭代器。
            return transformer(iterator.next())
        }
        override fun hasNext(): Boolean {
            return iterator.hasNext()
        }
    }
    internal fun <E> flatten(iterator: (R) -> Iterator<E>): Sequence<E> {
        return FlatteningSequence<T, R, E>(sequence, transformer, iterator)
    }
}

代碼并不復(fù)雜，它接收用戶提供的變換函數(shù)和序列，然后創(chuàng)建了一個TransformingSequence并返回。TransformingSequence本身和上文中提到的序列沒什么區(qū)別，唯一的區(qū)別在于它的迭代器：在通過next依次取數(shù)據(jù)的時候，并不是直接返回元素。而是先調(diào)用調(diào)用者提供的函數(shù)進(jìn)行變換。返回變換后的數(shù)據(jù)——這也沒什么新鮮的，和普通集合的map操作符和RxJava的Map都是同樣的原理。

但是，這里卻又有點(diǎn)不一樣。操作符里沒有任何開啟迭代的代碼，它只是對序列以及迭代進(jìn)行了嵌套處理，并不會開啟迭代.如果用戶不手動調(diào)用（后者間接調(diào)用）迭代器的next函數(shù)，序列就不會被執(zhí)行——這就是惰性執(zhí)行的機(jī)制的原理所在。

而且，由于操作符返回的是一個Sequence類型的值，當(dāng)你重復(fù)不斷調(diào)用map時，例如下面的代碼：

(0..10).asSequence().map{add(it)}.map{add(it)}.map{add(it)}.toList()
//等同于
val sequence1 = (0..10).asSequence()
val sequence2 = sequence1.map { it+1 }
val sequence3 = sequence2.map { it+1 }
sequence3.toList()

最終，序列sequence3的結(jié)構(gòu)持有如下：sequence3-> sequence2 -> sequence1。而它們都有各自的迭代器。迭代器里都重寫了各自的變換邏輯:

override fun next(): R {
	return transformer(iterator.next())
}
//由于這里都是執(zhí)行的+1操作，所以變換邏輯transformer可以認(rèn)為等同于如下操作:
override fun next(): R {
	return iterator.next()+1
}

而當(dāng)我們通過sequence3.toList執(zhí)行代碼時，它的流程如下：

public fun <T> Sequence<T>.toList(): List<T> {
    return this.toMutableList().optimizeReadOnlyList()
}
public fun <T> Sequence<T>.toMutableList(): MutableList<T> {
	//末端操作符，此處才會開始創(chuàng)建新的集合
    return toCollection(ArrayList<T>())
}
public fun <T, C : MutableCollection<in T>> Sequence<T>.toCollection(destination: C): C {
    //執(zhí)行迭代器next操作
    //當(dāng)調(diào)用（末端操作符）走到這里時，便會和普通結(jié)合的操作符一樣
    //此時為新創(chuàng)建的集合賦值
    for (item in this) {
        destination.add(item)
    }
    return destination
}

經(jīng)過幾次擴(kuò)展函數(shù)調(diào)用，最終在toCollection里開始執(zhí)行迭代(Iterator的典型的操作)，也就是獲取了sequence3的iterator實(shí)例，并不斷通過next取出數(shù)據(jù)。而在上文中的TransformingSequence源碼里可以看到，TransformingSequence會持有上一個迭代器的實(shí)例（代碼注釋一）。

并且在迭代開始后，在進(jìn)行transformer操作（也就是執(zhí)行+1操作）前，會調(diào)用上一個迭代器的next方法進(jìn)行迭代（代碼注釋二）。這樣不斷的迭代，最終，最終會調(diào)用到sequence1的next方法。再結(jié)合上文中的序列創(chuàng)建里的分析——sequence1里所持有的迭代器就是就是原始數(shù)據(jù)里的迭代器。

那么當(dāng)最終執(zhí)行toList方法時，它會循環(huán)sequence3.iterator方法。而在每次循環(huán)內(nèi)，都會首先執(zhí)行sequence3所持有的sequence2.iterator的next方法。sequence2依次類推執(zhí)行到sequence1的sequence1.iterator`方法，最終執(zhí)行到我們原始數(shù)組的迭代器next方法：

整個流程如下：

原理就是這么簡單：中間操作符通過序列嵌套，實(shí)現(xiàn)對迭代器iterator的嵌套。這樣在進(jìn)行迭代的時候，會依次調(diào)用各個iterator迭代器直到調(diào)用到原始集合數(shù)據(jù)里的迭代器開始并返回元素。而當(dāng)元素返回時，會依次執(zhí)行各個迭代器持有變換操作方法實(shí)現(xiàn)對數(shù)據(jù)的變換。

而其他操作符，也是遵循這個基本的規(guī)則。無非就是增加一些其他的操作。

總結(jié)

• 序列通過中間操作符對迭代器進(jìn)行嵌套和復(fù)寫，以此實(shí)現(xiàn)按元素操作執(zhí)行變換；
• 中間操作符只負(fù)責(zé)根據(jù)需求創(chuàng)建并嵌套迭代器，并不負(fù)責(zé)開啟迭代器。以此實(shí)現(xiàn)惰性操作且不產(chǎn)生臨時集合；
• 末端操作符負(fù)責(zé)開啟迭代，按照嵌套順序執(zhí)行迭代操作。依次獲取操作后的數(shù)據(jù)，并且會創(chuàng)建新的集合用來存儲最終數(shù)據(jù)；
• 序列不是萬能的，因?yàn)橐胄碌膶ο?。在帶來惰性和順序?zhí)行的優(yōu)勢時，這些對象必然會帶來性能開銷。所以要依需求在集合和序列之間進(jìn)行選擇，使用合適的方式進(jìn)行迭代。

以上就是Kotlin中的惰性操作容器Sequence序列使用原理詳解的詳細(xì)內(nèi)容，更多關(guān)于Kotlin惰性容器Sequence的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論