Functional programming 是否有任何rxjava操作符像throttle而不是filter？

假设有一个高速公路入口和一个停车标志

规则如下：

1、第一辆无需等待立即进入高速公路的车。 2、任何其他时间，其他车辆必须在前一辆车通过后至少等待2.5秒。 3，请注意，这并不意味着所有车辆必须等待2.5秒。 例如，第一辆车立即通过。10小时后，第二辆车来了。它应该马上过去，因为第一辆车已经过去了10个小时，这是很久以前的事了。 让第二辆车等2.5秒是没有意义的。但假设在第二辆车出现1200毫秒后，第三辆车出现了，这辆车立刻就过去了。第三辆车需要等待1300毫秒

我在github中使用了单元测试的代码，并且单元测试通过了。但我真的不喜欢我引入了副作用这一事实

    private int passedCarCount;
    private int timeSpanCount;

因此，我编写这个示例应用程序是希望请rx专家优化代码。如果我们能以干净的方式完成，我们将不胜感激

package com.tonytangandroid.rxjava_stop_sign.demo;

import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.Scheduler;

public class ThrottleCarStream {

    private final CarStream carStream;
    private final Scheduler scheduler;
    private int passedCarCount;
    private int timeSpanCount;

    public ThrottleCarStream(CarStream carStream, Scheduler scheduler) {
        this.carStream = carStream;
        this.scheduler = scheduler;
    }


    public Observable<Car> periodUserActionStream() {
        return zip();
    }


    private Observable<Car> zip() {
        return Observable.zip(rawStream(), internal(), this::value);
    }

    private Observable<Long> internal() {
        return Observable.interval(0, 2500, TimeUnit.MILLISECONDS, scheduler)
            .doOnSubscribe(disposable -> initSpanCount())
            .filter(c -> whenCarCountGreaterOrEqualThanTimeSpanCount())
            .doOnNext(aLong -> increaseSpanCount());
    }

    private boolean whenCarCountGreaterOrEqualThanTimeSpanCount() {
        return passedCarCount >= timeSpanCount;
    }

    private void increaseSpanCount() {
        timeSpanCount++;
    }

    private void initSpanCount() {
        timeSpanCount = 0;
    }

    private Car value(Car cmdMessage, Long time) {
        return cmdMessage;
    }

    private Observable<Car> rawStream() {
        return carStream.cmdStream()
            .doOnSubscribe(disposable -> initElementCount())
            .doOnNext(cmdMessage -> increaseElementCount());
    }

    private void increaseElementCount() {
        passedCarCount++;
    }

    private void initElementCount() {
        passedCarCount = 0;
    }


}

package com.tonytangandroid.rxjava\u stop\u sign.demo；
导入java.util.concurrent.TimeUnit；
导入io.reactivex.Observable；
导入io.reactivex.Scheduler；
公共类ThrottleCastream{
私人最终车流；
专用最终调度器；
私用整数密码；
私人国际时间统计；
公共ThrottleCarStream（CarStream、调度程序）{
this.carStream=carStream；
this.scheduler=调度程序；
}
公共可观测时段UserActionStream（）{
返回zip（）；
}
私有可观察zip（）{
返回Observable.zip（rawStream（），internal（），this:：value）；
}
私有可观测内部（）{
返回可观察的时间间隔（0，2500，TimeUnit.ms，调度程序）
.doOnSubscribe（一次性->initSpanCount（））
.filter（c->WhenCarCountgreater或QualthAntimespanCount（））
.doOnNext（沿->增加spanCount（））；
}
私有布尔值WhenCarCountGreater或QualthAntiSpanCount（）时{
返回passedCarCount>=timeSpanCount；
}
私有void递增spancount（）{
timeSpanCount++；
}
私有void initSpanCount（）{
timeSpanCount=0；
}
私家车价值（汽车信息，长时间）{
返回消息；
}
私有可观测原始流（）{
返回carStream.cmdStream（）
.doOnSubscribe（一次性->initElementCount（））
.doOnNext（cmdMessage->increaseElementCount（））；
}
私有void increaseElementCount（）{
passedCarCount++；
}
私有void initElementCount（）{
passedCarCount=0；
}
}

这应该可以：

@RequiredArgsConstructor
公共类DelayTransformer实现了ObservateTransformer{
private Long last=null；
最终长期限制；
@凌驾
公共可观测资源应用（最终可观测上游）{
返回上游。平面图（x->{
最终长电流=System.currentTimeMillis（）；
最终长延迟=最后==空？
0:Math.max（0，limit-（current-last））；
last=电流+延迟；
返回可观察的.just（x）.delay（delay，TimeUnit.ms）；
});
}
}
//来电者
可观察的car1=可观察的
.just（“car1”）
.延迟（100，时间单位毫秒）；
可观察的car2=可观察的
.just（“car2”）
.延迟（200，时间单位为毫秒）；
可观察的car3=可观察的
.just（“car3”）
.延迟（2500，时间单位为毫秒）；
可观察的汽车=可观察的
.合并（car1、car2、car3）；
汽车
.doOnNext（x->log.info（“接收：{}”，x））
.compose（新变压器（1500））
.blockingSubscribe（x->log.info（“发出：{}”，x））；

我得到了这个输出：

[INFO ] 2019-12-28 01:11:06.107 [RxComputationThreadPool-1] App - Received: car1
[INFO ] 2019-12-28 01:11:06.128 [main] App - Emitted: car1
[INFO ] 2019-12-28 01:11:06.189 [RxComputationThreadPool-2] App - Received: car2
[INFO ] 2019-12-28 01:11:07.622 [main] App - Emitted: car2
[INFO ] 2019-12-28 01:11:08.490 [RxComputationThreadPool-3] App - Received: car3
[INFO ] 2019-12-28 01:11:09.122 [main] App - Emitted: car3

---

谢谢你努力帮助我。解决方案是有效的。但是我想知道我们是否有可能避免使用

System.currentTimeMillis（）

？那么，您应该能够使用

System.nanoTime（）也是。