web-dev-qa-db-fra.com

RxJava - Just vs De

J'obtiens le même résultat en utilisant Observable.just vs Observable.from dans le cas suivant:

 public void myfunc() {
 //swap out just for from here and i get the same results,why ?
        Observable.just(1,2,3).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.d("","all done. oncompleted called");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.d("","here is my integer:"+integer.intValue());
            }
        });

    }

Je pensais que c'était simplement just supposer d'émettre un seul élément et from était d'émettre des éléments dans une sorte de liste. Quelle est la différence ? J'ai également noté que just et from ne prend qu'un nombre limité d'arguments. alors Observable.just(1,2,3,4,5,6,7,8,-1,-2) est ok mais Observable.just(1,2,3,4,5,6,7,8,-1,-2,-3) échoue. Même chose pour de, je dois l'envelopper dans une liste ou un tableau de toutes sortes. Je suis juste curieux de savoir pourquoi ils ne peuvent pas définir d'arguments illimités. 

UPDATE: J'ai expérimenté et vu que just ne prend pas de structure de tableau, il just prend des arguments. from prend une collection. donc, ce qui suit fonctionne pour from mais pas pour just:

 public Observable myfunc() {
    Integer[] myints = {1,2,3,4,5,6,7,8,-1,-2,9,10,11,12,13,14,15};
   return  Observable.just(myints).flatMap(new Func1<Integer, Observable<Boolean>>() {
        @Override
        public Observable<Boolean> call(final Integer integer) {
            return Observable.create(new Observable.OnSubscribe<Boolean>() {
                @Override
                public void call(Subscriber<? super Boolean> subscriber) {
                    if(integer.intValue()>2){
                        subscriber.onNext(integer.intValue()>2);

                    }
                }
            });
        }
    });

}

Je suppose que c'est la différence évidente, n'est-ce pas?

rx-java
28
j2emanue

La différence devrait être plus claire lorsque vous examinez le comportement de chacun lorsque vous lui transmettez une Iterable (par exemple une List):

Observable.just(someList) vous donnera 1 émission - une List.

Observable.from(someList) vous donnera N émissions - chaque élément de la liste.

La possibilité de transmettre plusieurs valeurs à just est une fonctionnalité pratique; les fonctions suivantes sont identiques:

Observable.just(1, 2, 3);
Observable.from(1, 2, 3);
68
Adam S

Différence entre just() et from():

Bien que just() et from() semblent effectuer le même travail, le nombre d’émissions diffère.

just() - Ne produit qu'une seule émission. Observable.just(new Integer[]{1, 2, 3}) effectue une émission avec le rappel de l'observateur sous la forme onNext(Integer[] integers)

fromArray() - Génère des émissions d'azote. Observable.fromArray(new Integer[]{1, 2, 3}) effectue trois émissions avec le rappel de l'observateur sous la forme onNext(Integer integer)

4
Zubair Rehman

inRxJava Just () operator prend une liste d'arguments et convertit les éléments en éléments observables. Cela prend des arguments entre un et dix (mais le document officiel dit un à neuf, peut-être est-il spécifique à la langue).

Contrairement à just, From () crée un observable à partir d’un ensemble d’éléments utilisant un Iterable, ce qui signifie que chaque élément est émis un à un.

0
Faisal Naseer

from fonctionne principalement avec des structures de données (tableaux et itérables) et des contrats à terme. Ainsi, le Observable obtenu émettra des éléments uniques à partir de ces structures de données ou contrats à terme.

just traite tout comme élément, qu'il s'agisse d'un élément de tableau ou d'un élément entier. La confusion autour de just est générée par le fait qu'il existe quelques variantes just pouvant accepter jusqu'à 10 arguments.

Donc, en fait, vous pouvez interpréter toutes ces variantes just comme émettant, respectivement, "juste" un élément, ou "seulement" deux éléments, "seulement" trois éléments et ainsi de suite ...

0
vortex.alex