Rx java RxJava：在不删除元素的情况下计数或时间跨度窗口

我想将我的流划分为具有一定最大大小的批，如果一段时间后未达到此大小，请关闭批并启动一个新的批。 为此，我尝试使用窗口（计数）：

然而，这要等到接收到10个元素后才能发出新的可观察窗口。 如果我使用窗口（timespan， 单位,， 计数）操作员：

things.window(1, TimeUnit.SECONDS, 10)

我将在10号之后和时间跨度完成之前释放所有元素

我想要一个类似的操作符，它不是等待timespan完成，而是在达到计数时发出一个新窗口

things.windowXXX(timespan = 1s, count = 2) : Observable[T]

things:   ----o--o--o-----------o----o------->
timespan: [      )[    1s    ][      )[    -->
window 1: -----o-o-|
window 2:          -o---------|
window 3:                     --o-----o-| 

---

我找到了一种解决这个问题的方法，使用缓冲区（timespan，timeunit，count）而不是窗口。 我认为缓冲区和窗口具有相同的行为，一个发出列表，另一个发出观察值。但这里似乎有区别

我的解决方案是使用缓冲区，然后将每个结果映射到一个可观察的对象：

observable.buffer(10, TimeUnit.MILLISECONDS, 2)
          .map(new Func1<List<String>, Observable<String>>() {
                public Observable<String> call(List<String> l) {
                    return Observable.from(l);
                }
           })

印刷品：

窗口-1968827463:1
窗口-1968827463:2
窗口-1968827463:3
窗口-1267747034:4
窗口-1267747034:5

请注意，它发出两个批次而不是三个，第一个批次有三个元素而不是两个

另一方面，通过使用缓冲区：

    observable.map(delayOn4).buffer(10, TimeUnit.MILLISECONDS, 2)
            .map(new Func1<List<String>, Observable<String>>() {
                public Observable<String> call(List<String> l) {
                    return Observable.from(l);
                }
            }).subscribe(new UpdateCountdowns("buffer"));
    assertTrue(itemsCount.await(100, TimeUnit.MILLISECONDS));
    assertTrue(batchesCount.await(100, TimeUnit.MILLISECONDS));

observable.map（delayOn4）.buffer（10，TimeUnit.ms，2）
.map（新函数1（）{
公共可观测呼叫（列表l）{
从（l）中可观察到的回报；
}
}).订阅（新的更新计数（“缓冲”）；
assertTrue（itemsCount.await（100，时间单位毫秒））；
assertTrue（batchesCount.await（100，时间单位毫秒））；

印刷品：

缓冲区-1257525795:1
缓冲区-1257525795:2
缓冲区-1849466438:3
缓冲区-104886386:4
缓冲区-104886386:5

三批最多两个元素，因为“4”到达晚了，所以在下一批中结束

我不知道这是否是预期的行为，或者其中可能存在错误

    observable.map(delayOn4).window(10, TimeUnit.MILLISECONDS, 2)
            .subscribe(new UpdateCountdowns("window"));
    assertTrue(itemsCount.await(100, TimeUnit.MILLISECONDS));
    assertTrue(batchesCount.await(100, TimeUnit.MILLISECONDS));

    observable.map(delayOn4).buffer(10, TimeUnit.MILLISECONDS, 2)
            .map(new Func1<List<String>, Observable<String>>() {
                public Observable<String> call(List<String> l) {
                    return Observable.from(l);
                }
            }).subscribe(new UpdateCountdowns("buffer"));
    assertTrue(itemsCount.await(100, TimeUnit.MILLISECONDS));
    assertTrue(batchesCount.await(100, TimeUnit.MILLISECONDS));