Eine ausführliche Erläuterung der Details von RxJava_06 [Bedingungen und Kombinationsoperationen des Übertragungsprozesses]

Dieses Tutorial basiert auf RxJava1 >Die folgende Reihe von Funktionen wird verwendet, um festzustellen, ob die übertragenen Daten übereinstimmen bestimmte Bedingungen.

alle – Bestimmen Sie, ob alle vom Observable ausgegebenen Daten eine bestimmte Bedingung erfüllen. Wenn Daten im ursprünglichen Observable die Bedingung nicht erfüllen, wird False zurückgegeben

1. Amb – Bei 2 Observablen wird nur das Observable gesendet, das zuerst Daten sendet, und letzteres wird ignoriert.

2. Contains – Bestimmt, ob ein Observable einen bestimmten Wert ausgibt

3. DefaultIfEmpty – Gibt den Wert aus dem ursprünglichen Observable aus, wenn das ursprüngliche Observable nicht ausgegeben hat irgendein Wert, einen Standardwert ausgeben

4. SequenceEqual – bestimmen, ob zwei Observables dieselbe Datensequenz ausgeben

5. SkipUntil – SkipUntil abonniert das ursprüngliche Observable , ignoriert jedoch seine Emitter, bis das zweite Observable ein Element ausgibt, und beginnt dann mit der Emission des ursprünglichen Observable.

6. SkipWhile – SkipWhile abonniert das ursprüngliche Observable, ignoriert jedoch dessen Emitter bis zu diesem Zeitpunkt Wenn eine bestimmte von Ihnen angegebene Bedingung falsch wird, beginnt die Ausgabe des ursprünglichen Observable.

7. TakeUntil – verwendet eine Prädikatfunktion anstelle eines zweiten Observable, um zu bestimmen, ob die ausgegebenen Daten beendet werden müssen. Es verhält sich ähnlich wie takeWhile.

8. TakeWhile – TakeWhile gibt das ursprüngliche Observable aus, bis eine bestimmte von Ihnen angegebene Bedingung nicht wahr ist. An diesem Punkt stoppt es die Ausgabe des ursprünglichen Observable und beendet sein eigenes Observable.

9. 1.all

Bestimmen Sie, ob alle vom Observable ausgegebenen Daten eine bestimmte Bedingung erfüllen. Wenn eine der Daten im ursprünglichen Observable die Bedingung nicht erfüllt, Falsch

Wenn Informationen zu Gruppenschülern vorliegen, lauten die Daten wie folgt:

Sie dürfen bei der Einschreibung in die Schule nicht älter als 20 Jahre sein Sie können die All-Funktion zur Beurteilung verwenden.

private ArrayList<Student> initStudents() {
    ArrayList<Student> persons = new ArrayList<>();
    persons.add(new Student("张三", 16));
    persons.add(new Student("李四", 21));
    persons.add(new Student("王二麻子", 18));
    return persons;
}

2.Amb

Observable<Student> observable = Observable.from(initStudents());
Observable<Boolean> booleanObservable = 
                observable.all(new Func1<Student, Boolean>() {
                    //设置判断规则
                    @Override
                    public Boolean call(Student student) {
                        return student.age<20;
                    }
                });
booleanObservable.subscribe(new Action1<Boolean>() {
    @Override
    public void call(Boolean aBoolean) {
        //这里打印了false  因为学生里面李四21岁
        Log.i(TAG, "call: "+aBoolean);
    }
});

Bei zwei oder mehr Observablen werden nur alle Daten des Observablen ausgegeben, das zuerst Daten oder Benachrichtigungen ausgibt, und alle anderen Observablen werden ignoriert und verworfen Projektile.

3.Contains

Observable<String> o1 = Observable.just("a", "b", "c");
Observable<String> o2 = Observable.just("d", "f", "e");

//判断上面的2个被观察者对象哪个先发送数据 发送数据慢的被观察者将被忽略
Observable<String> observable = Observable.amb(o2,o1);

observable.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        Log.i(TAG, "call: "+s);
    }
});

Übergeben Sie einen angegebenen Wert an Contains. Wenn das ursprüngliche Observable diesen Wert ausgibt, gibt das von ihm zurückgegebene Observable „true“ aus, andernfalls gibt es „false“ aus.

4.DefaultIfEmpty

Observable<String> o1 = Observable.just("a", "b", "c");
Observable<Boolean> observable = o1.contains("a");

observable.subscribe(new Action1<Boolean>() {
    @Override
    public void call(Boolean aBoolean) {
        //true
        Log.i(TAG, "call: "+aBoolean);
    }
}

DefaultIfEmpty gibt einfach den Wert des ursprünglichen Observables genau aus. Wenn das ursprüngliche Observable keine Daten ausgibt und normal endet (in der Form von onCompletedd), wird das Das von DefaultIfEmpty zurückgegebene Observable gibt einen von Ihnen bereitgestellten Standardwert aus.

Wenn der Beobachter beispielsweise auf die Netzwerkanforderung zugreift, gibt der Hintergrundserver die Rückgabedaten nicht zurück und stattdessen können Standarddaten verwendet werden.

Observable<String> o1 = Observable
        .create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //这里没有发送任何onNext事件,而是调用onCompleted()事件
                subscriber.onCompleted();
            }
        });
    //如果上面的o1不发送任何onNext而结束 则发送一个默认的值d
    Observable<String> o2 = o1.defaultIfEmpty("d");
    o2.subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            //打印d
            Log.i(TAG, "call: "+s);
        }
    });

5.SequenceEqual

Bestimmt, ob zwei Observablen dieselbe Datensequenz aussenden. Es werden die Emissionen der beiden Observablen verglichen (gleiche Reihenfolge, gleicher Beendigungsstatus), gibt es „true“ aus, andernfalls gibt es „false“ aus.

6.1 SkipUntil

Observable<Integer> o1 = Observable.just(1,2,3);
Observable<Integer> o2 = Observable.just(1,2,3);
Observable<Boolean> observable = Observable.sequenceEqual(o1, o2);

observable.subscribe(new Action1<Boolean>() {
    @Override
    public void call(Boolean aBoolean) {
        Log.i(TAG, "call: "+aBoolean);
    }
});

SkipUntil abonniert das ursprüngliche Observable, ignoriert jedoch seine Emitter, bis das zweite Observable ein Datenelement ausgibt, und beginnt dann mit der Aussendung des ursprünglichen Observable.

Ausgabe:

Observable<Integer> o1 = Observable.just(1,2,3);
Observable<Integer> o2 = o1.skipUntil(Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> subscriber) {
        //如果不发送如下信息  则上面的1,2,3都不会发送
        //如果发送了4 则直接发送1,2,3 但是4 5并没有发送
        subscriber.onNext(4);
        subscriber.onNext(5);
    }
}));

o2.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer value) {
        Log.i(TAG, "call: "+value);
    }
});

6.2 SkipUntil

call: 1
call: 2
call: 3

SkipWhile abonniert das ursprüngliche Observable, ignoriert jedoch seine Emitter, bis eine von Ihnen angegebene Bedingung zum Moment falsch wird. Es beginnt mit der Ausgabe des ursprünglichen Observable.

Ausgabe:

Observable<Integer> o1 = Observable.just(1,2,3,4,5,6);
Observable<Integer> o2 = o1.skipWhile(new Func1<Integer, Boolean>() {
    @Override
    public Boolean call(Integer value) {
        //直到发送的数据"等于"4 才开始从4发送数据 这里打印4,5,6
        return value!=4;
    }
});

o2.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer value) {
        Log.i(TAG, "call: "+value);
    }
});

7.1 TakeUntil

call: 4
call: 5
call: 6

Verwenden Sie eine Funktion in takeUntil, um zu entscheiden, ob die nachfolgenden Daten beendet und mit dem Senden fortgefahren werden sollen. Der Code lautet wie folgt:

Der obige Code ähnelt:

Observable<Integer> o1 = Observable.just(1,2,3,4,5,6);
Observable<Integer> o2 = o1.takeUntil(new Func1<Integer, Boolean>() {
    @Override
    public Boolean call(Integer value) {
        //发送数据直到等于4才停止发送
        return value==4;
    }
});

o2.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer value) {
        Log.i(TAG, "call: "+value);
    }
});

7.2 TakeWhile

ArrayList<Integer> datas=new ArrayList<>();
for (int i = 1; i <= 6 ; i++) {
    datas.add(i);
}
int index=0;
while(datas.get(index)<=4){
    Log.i(TAG, "onCreate: "+datas.get(index));
    index++;
}

TakeWhile gibt das ursprüngliche Observable aus, bis eine bestimmte von Ihnen angegebene Bedingung erreicht ist ist nicht wahr. Für einen Moment hört es auf, das ursprüngliche Observable auszusenden und beendet sein eigenes Observable.

Der obige Code gibt 1~4 aus, ähnlich der folgenden while-Anweisung:

Observable<Integer> o1 = Observable.just(1,2,3,4,5,6);
Observable<Integer> o2 = o1.takeWhile(new Func1<Integer, Boolean>() {
    @Override
    public Boolean call(Integer integer) {
        //发送数据 直到发送的数据等于才停止发送
        return integer!=5;
    }
});

o2.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer value) {
        Log.i(TAG, "call: "+value);
    }
});

Die unten gezeigte Funktion kann verwendet werden, um mehrere Observablen zu kombinieren.

ArrayList<Integer> datas=new ArrayList<>();
for (int i = 1; i <= 6 ; i++) {
    datas.add(i);
}
int index=0;
while(datas.get(index)!=5){
    Log.i(TAG, "onCreate: "+datas.get(index));
    index++;
}

---

Merge – Verschachteltes Zusammenführen von Emissionen aus mehreren Observablen

1. StartWith – Fügt das angegebene Element am Anfang der Datensequenz ein

2. Zip – Füge die Emissionsdaten von zwei Observablen gemäß den von der Funktion bereitgestellten Regeln zusammen. Die Gesamtzahl der Emissionsdaten basiert auf der Mindestanzahl der beobachtbaren Emissionen.

3. 8.Zusammenführen

Führen Sie die Emissionen mehrerer Observablen zusammen. Mit dem Merge-Operator können Sie die Ausgabe mehrerer Observables zusammenführen, als wären sie ein einzelnes Observable.

Die Zusammenführung kann dazu führen, dass die von zusammengeführten Observablen ausgegebenen Daten verschachtelt werden (es gibt einen ähnlichen Operator Concat, der die Daten nicht verschachtelt, sondern die Emissionen mehrerer Observablen nacheinander der Reihe nach ausgibt).

Beispielcode

Ausgabe

Observable<Integer> odds = Observable.just(1, 3, 5).subscribeOn(someScheduler);
Observable<Integer> evens = Observable.just(2, 4, 6);

Observable.merge(odds, evens)
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

9.StartWith

Next: 1
Next: 3
Next: 5
Next: 2
Next: 4
Next: 6
Sequence complete.

Fügt das angegebene Element am Anfang der Datensequenz ein

Wenn Sie möchten, dass ein Observable eine bestimmte Datensequenz ausgibt, bevor es Daten ausgibt, können Sie den StartWith-Operator verwenden. (Wenn Sie eine Datensequenz an das Ende der von einem Observable ausgegebenen Daten anhängen möchten, können Sie den Concat-Operator verwenden.)

Observable<String> o1 = Observable.just("模拟网络请求");
Observable<String> o2 = o1.startWith("网络请求之前的准备工作");
o2.subscribe(new Action1<String>() {
    @Override
    public void call(String value) {
        Log.i(TAG, value);
    }
});

输出：

网络请求之前的准备工作
模拟网络请求

类似的函数有：

• Javadoc: startWith(Iterable))

• Javadoc: startWith(T)) (最多接受九个参数)

• Javadoc: startWith(Observable))

10.Zip

假设被观察者o1发送的数据为1 2 ，被观察者o2发送的数据为3，4，5。那么zip压缩发送的数据个数以最低个也就是2个为准。并且 新发送的每个数据以Func2的返回数据为准。

• Javadoc: zip(Observable1,Observable2,Func2));

示例代码如下：

Observable<Integer> o1 = Observable.just(1,2);
Observable<Integer> o2 = Observable.just(3,4,5);

Observable<Integer> zipObservable = Observable
        .zip(o1, o2, new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer o, Integer o2) {
                return o + o2;
            }
        });

zipObservable.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer s) {
        Log.i(TAG, "call: "+s);
    }
});

输出如下：

call: 4 // 1+3
call: 6   // 2+4

 以上就是深入浅出RxJava_06[传输过程的条件&组合操作]的详情的内容，更多相关内容请关注PHP中文网（www.php.cn）！