Pagination 如何使用以前观察到的信息进行分页

假设我有一个名为

listOf（int-page）

的阻塞方法。 如果我想对这样的内容进行分页，一个想法是这样做：

public Observable<UUID> allOf(int initialPage) {
    return fromCallable( () -> listOf(initialPage))
            .concatWith( fromCallable( () -> allOf(initialPage + 1)))
            .flatMap(x -> from(x));
}

public observeable allOf（int initialPage）{
从Callable（（）->listOf（initialPage））返回
.concatWith（fromCallable（（）->allOf（initialPage+1）））
.flatMap（x->from（x））；
}

如果我的服务不使用页码，而是使用列表的最后一个元素来查找下一个元素，那么如何使用

RxJava

我仍然希望获得执行类似

allOf（0）的操作的效果。获取（20）

，并在第一个操作完成后，使用

concatWith

获取对第二个可观察对象的调用

---

但是，当我需要上一次通话中的信息时，我该怎么做呢？

您可以使用主题将下一页号码发回序列的开头：

List<Integer> service(int index) {
    System.out.println("Reading " + index);
    List<Integer> list = new ArrayList<>();
    for (int i = index; i < index + 20; i++) {
        list.add(i);
    }
    return list;
}

Flowable<List<Integer>> getPage(int index) {
    FlowableProcessor<Integer> pager = UnicastProcessor.<Integer>create()
        .toSerialized();
    pager.onNext(index);

    return pager.observeOn(Schedulers.trampoline(), true, 1)
    .map(v -> {
        List<Integer> list = service(v);
        pager.onNext(list.get(list.size() - 1) + 1);
        return list;
    })
    ;
}

@Test
public void testPager() {
    getPage(0).take(20)
    .subscribe(System.out::println, Throwable::printStackTrace);
}

列表服务（int索引）{
System.out.println（“读取”+索引）；
列表=新的ArrayList（）；
对于（int i=索引；i<索引+20；i++）{
列表.添加（i）；
}
退货清单；
}
可流动的getPage（int索引）{
FlowableProcessor pager=UnicastProcessor.create（）
.toSerialized（）；
pager.onNext（索引）；
return pager.observeOn（Schedulers.trampoline（），true，1）
.map（v->{
列表=服务（v）；
onNext（list.get（list.size（）-1）+1）；
退货清单；
})
;
}
@试验
公共void testPager（）{
获取第（0）页。获取第（20）页
.subscribe（System.out:：println，Throwable:：printStackTrace）；
}

为什么使用蹦床？以避免递归onNext调用。