Kotlin 如何合并两个独立的流，缓冲区填充的数据，并在一段时间后将其包含到其中

我试图测试这样的情况：

  val list1 = listOf(SomeClass1("1", 1), SomeClass1("2", 2), SomeClass1("3", 3))
    val list2 = listOf(SomeClass2(5.00), SomeClass2(4.00), SomeClass2(6.00))

    val someClass1Observable = Observable
            .fromIterable(list1)
            .zipWith(Observable.interval(2, TimeUnit.SECONDS),
                    BiFunction { item: SomeClass1, _: Long -> item })



    val someClass2Observable = Observable
            .fromIterable(list2)
            .zipWith(Observable.interval(1, TimeUnit.SECONDS),
                    BiFunction { item: SomeClass2, _: Long -> item })



    someClass1Observable.subscribe {
                Log.v("someClass1", it.toString())
            }

    someClass2Observable.subscribe {
                Log.v("someClass2", it.toString())
            }


    Observable.merge(someClass1Observable, someClass2Observable)
            .buffer(10, TimeUnit.SECONDS)
            .delay(10, TimeUnit.SECONDS)
            .doOnSubscribe { Log.v("parentObservable", "STARTED") }
            .subscribe { t: MutableList<Parent> ->
                Log.v("parentObservable", "onNext")
                t.forEach { Log.v("onNext", it.toString()) }
            }

    Thread.sleep(13000)

    someClass1Observable.subscribe {
        Log.v("someClass1", it.toString())
    }

    someClass2Observable.subscribe {
        Log.v("someClass2", it.toString())
    }

我有两个班级，都是从同一个家长那里延伸出来的

我正在为每个类创建和观察项目列表：

val listSomeClass1 = ArrayList<SomeClass1>()
val listSomeClass2 = ArrayList<SomeClass2>()

fun populateJust1() {
    listSomeClass1.add(SomeClass1("23", 23))
    listSomeClass1.add(SomeClass1("24", 24))
    listSomeClass1.add(SomeClass1("25", 25))
}

fun populateJust2() {
    listSomeClass2.add(SomeClass2(23.00))
    listSomeClass2.add(SomeClass2(24.00))
    listSomeClass2.add(SomeClass2(25.00))
}

populateItemsSomeClass1()
populateItemsSomeClass2()

在这里，我想合并它们的发射，缓冲它，并在10秒后订阅它：

      Observable.merge(someClass1Observable, someClass2Observable)
            .buffer(10, TimeUnit.SECONDS)
            .doOnSubscribe { Log.v("parentObservable", "STARTED") }
            .subscribe { t: MutableList<Parent> ->
                Log.v("parentObservable", "onNext")
                t.forEach { Log.v("onNext", it.toString()) }
            }

Observable.merge（someClassObservable，someClass2Observable）
.缓冲区（10，时间单位。秒）
.doOnSubscribe{Log.v（“parentObservable”，“STARTED”）}
.subscribe{t:MutableList->
Log.v（“parentObservable”、“onNext”）
t、 forEach{Log.v（“onNext”，it.toString（））}
}

然而，观测值并没有像我预期的那样在10秒后开始，而是在数据准备就绪的情况下立即开始。 如何模拟这样的情况，我将收集2个单独的流，10秒后我将能够获得收集的数据

我必须指出我不想使用任何主题。

更新

我做过这样的事：

  val list1 = listOf(SomeClass1("1", 1), SomeClass1("2", 2), SomeClass1("3", 3))
    val list2 = listOf(SomeClass2(5.00), SomeClass2(4.00), SomeClass2(6.00))

    val someClass1Observable = Observable
            .fromIterable(list1)
            .zipWith(Observable.interval(2, TimeUnit.SECONDS),
                    BiFunction { item: SomeClass1, _: Long -> item })



    val someClass2Observable = Observable
            .fromIterable(list2)
            .zipWith(Observable.interval(1, TimeUnit.SECONDS),
                    BiFunction { item: SomeClass2, _: Long -> item })



    someClass1Observable.subscribe {
                Log.v("someClass1", it.toString())
            }

    someClass2Observable.subscribe {
                Log.v("someClass2", it.toString())
            }


    Observable.merge(someClass1Observable, someClass2Observable)
            .buffer(10, TimeUnit.SECONDS)
            .delay(10, TimeUnit.SECONDS)
            .doOnSubscribe { Log.v("parentObservable", "STARTED") }
            .subscribe { t: MutableList<Parent> ->
                Log.v("parentObservable", "onNext")
                t.forEach { Log.v("onNext", it.toString()) }
            }

    Thread.sleep(13000)

    someClass1Observable.subscribe {
        Log.v("someClass1", it.toString())
    }

    someClass2Observable.subscribe {
        Log.v("someClass2", it.toString())
    }

val list1=listOf（SomeClass1（“1”，1），SomeClass1（“2”，2），SomeClass1（“3”，3））
val list2=listOf（一些类别2（5.00），一些类别2（4.00），一些类别2（6.00））
val=可观察到的
.fromIterable（列表1）
.zipWith（可观察的时间间隔（2，时间单位秒），
双功能{item:SomeClass1，ux:Long->item}）
val SomeClass2可观测=可观测
.fromIterable（列表2）
.zipWith（可观察的时间间隔（1，时间单位秒），
双功能{item:SomeClass2，uz:Long->item}）
订阅{
Log.v（“someClass1”，it.toString（））
}
someClass2Observable.subscribe{
Log.v（“someClass2”，it.toString（））
}
可观察。合并（someClassObservable，someClass2Observable）
.缓冲区（10，时间单位。秒）
.延迟（10，时间单位。秒）
.doOnSubscribe{Log.v（“parentObservable”，“STARTED”）}
.subscribe{t:MutableList->
Log.v（“parentObservable”、“onNext”）
t、 forEach{Log.v（“onNext”，it.toString（））}
}
线程。睡眠（13000）
订阅{
Log.v（“someClass1”，it.toString（））
}
someClass2Observable.subscribe{
Log.v（“someClass2”，it.toString（））
}

在这里，我只想模拟两个无限流的someClass1和someclass2观测值，对于合并观测值也是如此

---

同样，我希望能够合并这两个流，缓冲区填充的数据，并在10秒后对其进行处理。如果在10秒后，这两个流将再次填充一些数据，则merge Observable应该清除以前的缓冲区，并且应该再次缓冲新数据并在10秒后发出，依此类推。但是，我的代码没有按我预期的那样工作，我需要做哪些更改才能使其符合我的描述？

我想您正在寻找

延迟

操作符

耽搁 将可观察到的排放物在时间上向前移动特定量

比如：

.delay(10, TimeUnit.SECONDS)

---

谢谢你的建议，虽然很接近，但不是回答我问题的答案，请参阅我更新的问题，我做错了什么？