Question

我正试图测试这样的情况：

我有2个classess，它只是从同一个Parent扩展。

我正在从每个类的项目列表中创建和观察Observable：

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()

现在我可以创建2个observable：

  val someClass1Observable = Observable.fromIterable(listSomeClass1)
  val someClass2Observable = Observable.fromIterable(listSomeClass2)

在这里，我想合并它们的发射，缓冲它，并在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()) }
            }

然而，观察力并没有像我预期的那样在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())
    }

在这里，我想模拟someClass1和someclass2 Observables的2个无限流，并且对于合并Observable是相同的。

同样，我希望能够合并这两个流，缓冲填充的数据并在10秒后对其执行某些操作。如果10秒后这两个流将再次填充一些数据，合并Observable应该清理前一个缓冲区，并且应该再次缓冲新数据并在10秒后发出，依此类推，无限。但是，我的代码没有像我预期的那样工作，我需要做些什么改变才能按照我的描述去做？

Answer 1

我认为您正在寻找delay运营商

http://reactivex.io/documentation/operators/delay.html

延迟将Observable的排放量及时向前移动

类似于：

.delay(10, TimeUnit.SECONDS)

如何合并2个独立的流，缓存来自它们的填充数据，并在经过一段时间后将其下载到子流中

1 个答案: