Android RxJava2延迟不'；行不通

我有一个存储库方法：

public Maybe<String> getId(String id){
    return mApiInterface.get().getId(id)
            .subscribeOn(mSchedulerProvider.io())
            .observeOn(mSchedulerProvider.mainThread());
}

public-getId（字符串id）{
返回mApiInterface.get（）.getId（id）
.subscribeOn（mSchedulerProvider.io（））
.observeOn（mSchedulerProvider.mainThread（））；
}

我尝试在有延迟的循环中使用此方法：

 final ArrayList<String> ids = SharedPreferenceProvider.getIds();

    for(final String id:ids) {
        mRepository.get().getId(id)
                .delay(5, TimeUnit.SECONDS)
                .subscribeWith(new DisposableMaybeObserver<String>() {
                    @Override
                    public void onSuccess(String s) {  }

                    @Override
                    public void onError(Throwable e) { }

                    @Override
                    public void onComplete() {  }
                });
    }

final ArrayList id=SharedPreferenceProvider.getId（）；
for（最终字符串id:ids）{
mRepository.get（）.getId（id）
.延迟（5，时间单位。秒）
.subscribeWith（新的可处置资产可能是观察员）{
@凌驾
公共void onSuccess（字符串s）{}
@凌驾
公共无效者（可抛弃者）{}
@凌驾
公共void onComplete（）{}
});
}

但是延迟方法不起作用。我做错了什么？有时我需要两个请求之间的延迟

决策的最终变体：

Flowable.zip(Flowable.fromIterable(ids),
                        Flowable.interval(0, 5, TimeUnit.SECONDS).onBackpressureBuffer(),
                        new BiFunction<String, Long, String>() {
                            @Override
                            public String apply(String s, Long aLong) throws Exception {
                                return s;
                            }
                        }
                ).flatMapMaybe(new Function<String, MaybeSource<String>>() {
                    @Override
                    public MaybeSource<String> apply(String s) throws Exception {
                        return mRepository.get().testMaybe(s);
                    }
                }).subscribeWith(new DisposableSubscriber<String>() {
                    @Override
                    public void onNext(String s) {

                    }

                    @Override
                    public void onError(Throwable t) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

Flowable.zip（Flowable.fromIterable（ids），
可流动。间隔（0,5，时间单位。秒）。反向压力缓冲（），
新的双函数（）{
@凌驾
公共字符串apply（字符串s，长）引发异常{
返回s；
}
}
).flatmapmaybay（新函数（）{
@凌驾
公共MaybeSource apply（字符串s）引发异常{
返回mRepository.get（）.testMaybe；
}
}).subscribowith（新的可处置认购人（）{
@凌驾
public void onNext（字符串s）{
}
@凌驾
公共作废登记员（可丢弃的t）{
}
@凌驾
未完成的公共空间（）{
}
});

试试看

public Maybe<String> getId(String id){
    return mApiInterface.get().getId(id)
            .delay(5, TimeUnit.SECONDS)
            .subscribeOn(mSchedulerProvider.io());
}

public-getId（字符串id）{
返回mApiInterface.get（）.getId（id）
.延迟（5，时间单位。秒）
.subscribeOn（mSchedulerProvider.io（））；
}

//及

for（最终字符串id:ids）{
mRepository.get（）.getId（id）
.observeOn（mSchedulerProvider.mainThread（））
.subscribeWith（新的可处置资产可能是观察员）
{
@凌驾
公共void onSuccess（字符串s）{}
@凌驾
公共无效者（可抛弃者）{}
@凌驾
公共void onComplete（）{}
});
}

---

我需要每5秒发送一次id为的请求

但是我需要-mRepository.get（）.getId（id1）-等待5秒-mRepository.get（）.getId（id2）-等待5秒-等等

您可以使用间隔压缩，然后在存储库调用中使用flatMap

Flowable.fromArray(ids) // or fromIterable(ids)
.zipWith(
    Flowable.interval(0, 5, TimeUnit.SECONDS).onBackpressureBuffer(),
    (id, time) -> id
)
.flatMapMaybe(id -> mRepository.get().getId(id), 1)
// .repeat()
.subscribe(/* ... */)

---

您可以尝试使用延迟的debounce运算符。e、 g.debounce（TIME_REQUIRED，TimeUnit.ms）RxJava2中没有debounce和interval操作符，但可能没有。流动的和可观察的有那些它怎么“不起作用”？你的预期行为是什么？我需要每5秒发送一次id为的请求。阿卡诺克，谢谢。但这是错误的。此方法等待5秒，然后同时发送所有请求。之后，从5秒开始重复这个步骤。但是我需要-mRepository.get（）.getId（id1）-等待5秒-mRepository.get（）.getId（id2）-等待5秒-etcupated答案。你能用flatMapMaybe操作符显示所有代码吗？（没有lambda）间隔运算符是否停止？lambda表单有什么问题？任何现代IDE都可以将其转换为任何匿名的内部类表示。ID是有限的，因此

zipWith

一旦用完这些ID就会停止。

Flowable.fromArray(ids) // or fromIterable(ids)
.zipWith(
    Flowable.interval(0, 5, TimeUnit.SECONDS).onBackpressureBuffer(),
    (id, time) -> id
)
.flatMapMaybe(id -> mRepository.get().getId(id), 1)
// .repeat()
.subscribe(/* ... */)