Une explication approfondie des techniques de RxJava_04 [opération de filtrage de transmission de données]

Ce tutoriel est basé sur RxJava1 >Lorsque l'observateur envoie des données à l'observateur, les données peuvent devoir être filtrées davantage pendant la transmission des données. Le didacticiel suivant couvre les fonctions de la plupart des opérations de filtrage.
Distinct - supprime les données en double envoyées

Filtre - filtre les données spécifiques en fonction des conditions
First - Obtenez les premières données de la file d'attente d'envoi
Last - Obtenez les dernières données de la file d'attente d'envoi
ElementAt - Selon l'index Envoyer des données spécifiques dans la file d'attente
Take - Récupérer les n premiers éléments de données de la file d'attente
TakeLast - Récupérer les n derniers éléments de données dans la file d'attente
Sample - Envoyer en envoyant un échantillon de temps en fonction des données envoyées
IgnoreElements - Ignorer la file d'attente des données envoyées
1.Distinct

9. Il y a maintenant une classe et les informations sur les étudiants ont été saisies dans le système étudiant. Il s’est avéré que les mêmes données étaient répétées. La file d'attente des données des étudiants est la suivante :

Le besoin actuel est d'intercepter les objets portant des noms en double. Et imprimez-le :

Le résultat est le suivant :

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

2.Filtre

Observable
    .from(initPersons())
    //过滤重复名字的项
    .distinct(new Func1<Student, String>() {
        @Override
        public String call(Student student) {
            return student.name;
        }
    })
    .subscribe(new Action1<Student>() {
        @Override
        public void call(Student student) {
            Log.i(TAG, "call: "+student);
        }
    });

En plus de filtrer les parties répétées des données transmises , vous pouvez également utiliser le filtre Effacer des données spécifiques en fonction de règles.

Les données envoyées par le code suivant sont 12345. La règle de filtrage est que la barre de données doit être inférieure à 4. L'exemple de code est le suivant :

IT520: call: Student{name='张三', age=16}
IT520: call: Student{name='李四', age=17}
IT520: call: Student{name='王二麻子', age=18}

Sortie

3 .Premier

Observable.just(1, 2, 3, 4, 5)
      .filter(new Func1<Integer, Boolean>() {
          @Override
          public Boolean call(Integer item) {
            return( item < 4 );
          }
      })
      .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.");
            }
        });

Appelez cette fonction pour que la file d'attente des données envoyées envoie uniquement le premier élément.

Exemple de code

Next: 1
Next: 2
Next: 3
Sequence complete.

Sortie

Des fonctions similaires incluent firstOrDefault(), qui est envoyée dans la file d'attente si la file d'attente est null , qui Autrement dit, si le premier élément n'est pas trouvé, une valeur par défaut sera envoyée.

Observable.just(1, 2, 3)
      .first()
      .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.");
    }
});

4.Last

Next: 1
Sequence complete.

Appelez cette fonction pour envoyer uniquement le dernier élément de la file d'attente des données envoyées. Exemple de code

Sortie

Les fonctions similaires incluent lastOrDefault(T)

Observable.just(1, 2, 3)
      .last()
      .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.");
    }
});

5.

Next: 3
Sequence complete.

L'opérateur ElementAt obtient l'élément de données à la position d'index spécifiée de la séquence de données émise par l'observable d'origine, puis l'émet comme ses propres données uniques. Si vous transmettez un nombre négatif ou si le nombre d'éléments de données dans l'observable d'origine est inférieur à l'index 1, une IndexOutOfBoundsException sera levée.

L'exemple de code est le suivant :

Sortie

6.Take

Observable.just(1, 2, 3, 4, 1, 4)
    .elementAt(3)
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer value) {
            Log.i(TAG, "call: " + value);
        }
    });

L'utilisation de l'opérateur Take permet de modifier le comportement de l'Observable, seuls les N premiers éléments de données sont renvoyés, puis la notification d'achèvement est émise et les données restantes sont ignorées.

Exemple de code

com.m520it.rxjava I/IT520: call: 4

Sortie

7.TakeLast

Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
      .take(4)
      .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.");
            }
        });

Utilisez l'opérateur TakeLast pour modifier l'observable d'origine, vous pouvez simplement émettre l'Observable' Les N dernières données transmises sont ignorées. Les données précédentes sont ignorées.

Exemple de code

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

Sortie

8.Sample

Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
      .takeLast(4)
      .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.");
            }
        });

Échantillonnez les données envoyées à une certaine fréquence

Next: 5
Next: 6
Next: 7
Next: 8
Sequence complete.

Le code ci-dessus s'imprime : 0, 2, 4, 6, 8. . . .

9.IgnoreElements

Si vous ne vous souciez pas des données émises par un observable, mais souhaitez être averti lorsqu'il se termine ou se termine par une erreur, vous pouvez utiliser l'opérateur ignoreElements sur l'Observable, cela garantira que la méthode onNext() de l'observateur ne sera jamais appelée.

Observable
        .interval(1000, TimeUnit.MILLISECONDS)//每秒发送1个数字
        .sample(2000,TimeUnit.MILLISECONDS)//每2秒采样一次
        .subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                Log.i(TAG, "call: "+aLong);
            }
        });

Ce qui précède est une introduction approfondie aux techniques de RxJava_04 [opération de filtrage de transmission de données]. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !

Observable.just(1, 2, 3, 4, 1)
            .ignoreElements()//不发送任何信息 直接发送onCompleted()
            .subscribe(new Subscriber<Integer>() {
                @Override
                public void onCompleted() {
                    Log.i(TAG, "onCompleted: ");
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    Log.i(TAG, "onNext: "+integer);
                }
            });