Une explication approfondie des détails de RxJava_06 [Conditions et opérations de combinaison du processus de transmission]

Ce tutoriel est basé sur RxJava1>La série de fonctions suivante est utilisée pour déterminer si les données transmises sont conformes. certaines conditions.

tout - Détermine si toutes les données émises par l'Observable remplissent une certaine condition. Si des données de l'Observable d'origine ne remplissent pas la condition, False est renvoyé

1. Amb - Étant donné 2 observables, seul l'observable qui envoie des données en premier sera envoyé, et ce dernier sera ignoré.

2. Contient - Détermine si un observable émet une valeur spécifique

3. DefaultIfEmpty - Émet la valeur de l'observable d'origine si l'observable d'origine n'a pas émis n'importe quelle valeur, émet une valeur par défaut

4. SequenceEqual - détermine si deux observables émettent la même séquence de données

5. SkipUntil - SkipUntil s'abonne à l'observable d'origine , mais ignore ses émetteurs jusqu'à ce que le deuxième Observable émette un élément, lorsqu'il commence à émettre l'Observable d'origine.

6. SkipWhile - SkipWhile s'abonne à l'Observable d'origine, mais ignore son émetteur, jusqu'au moment une certaine condition que vous spécifiez devient fausse, elle commence à émettre l'Observable d'origine.

7. TakeUntil - utilise une fonction de prédicat au lieu d'un deuxième observable pour déterminer si les données émises doivent être terminées. Il se comporte de la même manière que takeWhile.

8. TakeWhile - TakeWhile émet l'observable d'origine jusqu'à ce qu'une certaine condition que vous spécifiez ne soit pas vraie, auquel cas il arrête d'émettre l'observable d'origine et met fin à son propre observable.

9. 1.all

Déterminer si toutes les données émises par l'Observable remplissent une certaine condition Si l'une des données de l'Observable d'origine ne remplit pas la condition, Faux

S'il existe des informations sur les élèves du groupe, les données sont les suivantes :

Vous devez avoir au maximum 20 ans lorsque vous entrez à l'école. peut utiliser la fonction all pour juger.

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);
    }
});

Étant donné deux observables ou plus, il émet uniquement toutes les données de l'observable qui émet en premier des données ou des notifications. Amb ignorera et rejettera tous les autres observables. projectiles.

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);
    }
});

Passez une valeur spécifiée à Contains. Si l'Observable d'origine émet cette valeur, l'Observable qu'il renvoie émettra vrai, sinon il émettra faux.

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 émet simplement la valeur de l'Observable d'origine avec précision. Si l'Observable d'origine n'émet aucune donnée et se termine normalement (sous la forme de onCompletedd), le L'observable renvoyé par DefaultIfEmpty émettra une valeur par défaut que vous fournissez.

Par exemple, lorsque l'observateur accède à la requête réseau, le serveur d'arrière-plan ne renvoie pas les données de retour et des données par défaut peuvent être utilisées à la place.

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

Détermine si deux observables émettent la même séquence de données. Il comparera les émissions des deux observables si les deux séquences sont identiques (mêmes données, la. même ordre, même statut de terminaison), il émet vrai, sinon il émet faux.

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 s'abonne à l'Observable d'origine, mais ignore ses émetteurs jusqu'à ce que le deuxième Observable émette un élément de données, lorsqu'il commence à émettre l'Observable d'origine.

Sortie :

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 s'abonne à l'Observable d'origine, mais ignore ses émetteurs, jusqu'à ce qu'une condition que vous spécifiez devienne Le moment faux, il commence à émettre l'Observable original.

Sortie :

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

Utilisez une fonction à l'intérieur de takeUntil pour décider de mettre fin aux données suivantes et de continuer l'envoi. Le code est le suivant :

Le code ci-dessus est similaire à :

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 émet l'Observable original jusqu'à ce qu'une certaine condition que vous spécifiez n'est pas vrai. Pendant un instant, il arrête d'émettre l'Observable original et met fin à son propre Observable.

Le code ci-dessus imprime 1 ~ 4, similaire à l'instruction while suivante :

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);
    }
});

La fonction illustrée ci-dessous peut être utilisée pour combiner plusieurs observables.

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++;
}

---

Fusion - Fusion entrelacée des émissions de plusieurs observables

1. StartWith - Insère l'élément spécifié au début de la séquence de données

2. Zip - Fusionner les données d'émission de deux observables selon les règles fournies par la fonction. Le nombre total de données d'émission doit être basé sur le nombre minimum d'émissions observables.

3. 8.Fusionner

Fusionner les émissions de plusieurs observables. À l’aide de l’opérateur Merge, vous pouvez fusionner la sortie de plusieurs observables comme s’il s’agissait d’un seul observable.

La fusion peut provoquer l'entrelacement des données émises par les observables fusionnés (il existe un opérateur similaire Concat qui n'entrelacera pas les données, il émettra les émissions de plusieurs observables les unes après les autres dans l'ordre).

Exemple de code

Sortie

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.

Insère l'élément spécifié au début de la séquence de données

Si vous souhaitez qu'un observable émette une séquence de données spécifiée avant d'émettre des données, vous pouvez utiliser l'opérateur StartWith. (Si vous souhaitez ajouter une séquence de données à la fin des données émises par un observable, vous pouvez utiliser l'opérateur Concat.)

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）！