RxJava2可流动区分最后一个元素

我想分批处理一个

可流动的
，在每批之后等待，直到完成一些异步工作而不阻塞线程，并以不同的方式处理最后一批。在
onComplete（）
中，是否有比使用
AtomicReference
缓存上一批并处理最后一批更好的方法

AtomicReference batchRef=新的AtomicReference（）；
可流动。仅（1,2,3,4,5,6）
.缓冲区（2）
.concatMapCompletable（批次->{
List previousBatch=batchRef.getAndSet（批次）；
如果（上一批！=null）{
System.out.println（“常规批次：+上一批次”）；
}
//这里会有异步的东西
返回Completable.complete（）；
})
.订阅（（）->{
System.out.println（“最后一批：+batchRef.get（））；
});
因此您希望以特定的方式对流事件做出反应。最简单的方法是创建自定义订户类，它完全满足您的需要：

static class MySubscriber implements FlowableSubscriber<List<Integer>> {
    List<Integer> previousBatch;

    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE);
    }

    @Override
    public void onNext(List<Integer> batch) {
        if (previousBatch != null) {
            System.out.println("Regular batch: " + previousBatch);
        }
        previousBatch = batch;
    }

    @Override
    public void onError(Throwable throwable) {}

    @Override
    public void onComplete() {
        System.out.println("Last batch: " + previousBatch);
    }
}

public static void main(String[] args) {
    Flowable.just(1, 2, 3, 4, 5, 6)
            .buffer(2)
            .subscribe(new MySubscriber());
}

静态类MySubscriber实现FlowableSubscriber{
列出前一批；
@凌驾
认购的公共无效（认购）{
s、 请求（长最大值）；
}
@凌驾
public void onNext（列表批处理）{
如果（上一批！=null）{
System.out.println（“常规批次：+上一批次”）；
}
previousBatch=批次；
}
@凌驾
公共无效者（可抛弃者）{}
@凌驾
未完成的公共空间（）{
System.out.println（“上一批：+上一批”）；
}
}
公共静态void main（字符串[]args）{
可流动。仅（1,2,3,4,5,6）
.缓冲区（2）
.subscribe（新的MySubscriber（））；
}

}
也许我应该说得更清楚些，但我不能使用
订阅服务器
，因为我想为每个批处理做一些异步工作，并且只在异步工作完成后才开始下一批处理——因此在我的示例中使用了
concatmappletable
。