在循环中RxJava中变量延迟前后执行函数

我有一个现有的Java代码，我想用RxJava编写。我正试图用一个自定义的模式振动一个设备

自定义模式的格式为

{onTime1，offTime1，onTime2，offTime2…}

其中， 设备在下一次振动之前，会振动

onTime

毫秒，并等待

offTime

以下是我的Java代码：

for (int i = 0; i < customPattern.length - 1; i++) {
            try {
                io.writeCharacteristic(Profile.UUID_SERVICE_VIBRATION, Profile.UUID_CHAR_VIBRATION, this.getProtocol());
                Thread.sleep(customPattern[i]);
                io.writeCharacteristic(Profile.UUID_SERVICE_VIBRATION, Profile.UUID_CHAR_VIBRATION, Protocol.STOP_VIBRATION);
                Thread.sleep(customPattern[i + 1]);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

给定这个数组作为输入{10,20,30,40,50}， 我想以以下方式执行

function1
wait(10)
function2
wait(20)
function1
wait(30)
function2
wait(40)
function1
wait(50)
function2

---

你可以这样做

创建一个表示开关延迟模式的Flowable

创建大小相等的交替真/假布尔流，指示是否应启用振动（或调用哪个方法）

将两个FlowTable压缩在一起并生成一个FlowTable，其中每个嵌套的FlowTable接受on-off值并在

doOnNext（…）

每个嵌套的Flowable随后将其自身的值延迟指定的延迟

最后，将嵌套的流连接在一起

您应该能够将其复制/粘贴到IDE中：

@Test
public void testVibrate()
{
    // Delay pattern:
    Flowable<Integer> pattern = Flowable.just(
            500,    // on
            250,    // off
            500,    // on
            250,    // off
            1000,   // on
            0 );    // off
            
    // Alternating true/false booleans:
    Flowable<Boolean> onOff = pattern
            .scan(
                    true,                                   // first value
                    ( prevOnOff, delay ) -> !prevOnOff );   // subsequent values
    
    // Zip the two together
    pattern.zipWith( onOff, ( delay, on ) -> Flowable.just( on )
            .doOnNext( __ -> System.out.println( "vibrate: " + on ))    // Invoke function based on value
            .delay( delay, TimeUnit.MILLISECONDS ))                     // Delay the value downstream
    .concatMap( on -> on )                                              // Concatenate the nested flowables
    .ignoreElements()
    .blockingAwait();
}

@测试
公共无效测试振动（）
{
//延迟模式：
可流动模式=可流动(
500，//on
250，//关
500，//on
250，//关
1000，//on
0）；//关
//交替使用真/假布尔值：
可流动onOff=模式
.扫描(
true，//第一个值
（prevOnOff，delay）->！prevOnOff）；//后续值
//把这两个拉链拉在一起
pattern.zipWith（onOff，（delay，on）->可流动。just（on）
.doOnNext（_->System.out.println（“振动：+on））//基于值调用函数
.delay（delay，TimeUnit.millides））//延迟下游的值
.concatMap（on->on）//连接嵌套的流
.ignoreElements（）
.阻塞等待（）；
}

您能否提供更多关于为什么必须使用Flowables的详细信息，并强调我的方法和您的方法之间的差异，例如为什么一种方法优于另一种方法other@struct_dhancha通过调用

Thread:：sleep

可以有效地从底层线程池中取出一个线程。它还可以用于在应用程序中执行其他一些工作负载。在这种情况下，它是可流动的还是可观察的并不重要。您可以将其更改为

可观察的

。使用延迟运算符会将一个值的发射延迟给定的时间段，对吗？因此，假设第一个值是

（500ms，true）

，那么在延迟500s后将调用onNext方法，并且由于

on

值是

true

，因此在延迟500s后将调用振动函数。我想要的是立即调用振动函数，然后等待500秒，然后调用停止函数…@struct_dhancha延迟操作符影响下游。第一次调用doOnNext立即发生。@struct_dhancha是的，没错。您最终得到了一个嵌套的

可流动
，执行
doOnNext
，然后是一个延迟。然后，您将
concatMap
嵌套的
Flowables
，生成一个
Flowables
的
Booleans
，您可以订阅，但忽略值本身。
@Test
public void testVibrate()
{
    // Delay pattern:
    Flowable<Integer> pattern = Flowable.just(
            500,    // on
            250,    // off
            500,    // on
            250,    // off
            1000,   // on
            0 );    // off
            
    // Alternating true/false booleans:
    Flowable<Boolean> onOff = pattern
            .scan(
                    true,                                   // first value
                    ( prevOnOff, delay ) -> !prevOnOff );   // subsequent values
    
    // Zip the two together
    pattern.zipWith( onOff, ( delay, on ) -> Flowable.just( on )
            .doOnNext( __ -> System.out.println( "vibrate: " + on ))    // Invoke function based on value
            .delay( delay, TimeUnit.MILLISECONDS ))                     // Delay the value downstream
    .concatMap( on -> on )                                              // Concatenate the nested flowables
    .ignoreElements()
    .blockingAwait();
}