Я получаю такой же вывод при использовании Observable.just против Observable.from в следующем случае:
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());
}
});
}
Я думал, что just предполагать, чтобы испустить один элемент, а from - в какой-то список. Какая разница? Я также отметил, что как just и from принимает лишь ограниченное количество аргументов. поэтому Observable.just(1,2,3,4,5,6,7,8,-1,-2) в порядке, но Observable.just(1,2,3,4,5,6,7,8,-1,-2,-3) не удается. То же самое касается, я должен обернуть его в список или массив сортов. Мне просто любопытно, почему они не могут определить неограниченные аргументы.
ОБНОВЛЕНИЕ: я экспериментировал и видел, что just не принимает структуру массива, он just принимает аргументы. from берет коллекцию. поэтому следующее работает from но не 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);
}
}
});
}
});
}
Я предполагаю, что это будет явной разницей, верно?
Разница должна быть более четкой, когда вы смотрите на поведение каждого, когда вы передаете ему Iterable (например, List):
Observable.just(someList) даст вам 1 эмиссию - List.
Observable.from(someList) даст вам N выбросов - каждый элемент в списке.
Возможность передачи нескольких значений just удобна; следующие функционально одинаковы:
Observable.just(1, 2, 3);
Observable.from(1, 2, 3);
Разница между just() и from() :
Все, хотя just() и from() похоже, выполняют одну и ту же работу, она отличается количеством выбросов.
just() - Делает только 1 эмиссию. Observable.just(new Integer[]{1, 2, 3}) делает одно излучение с обратным onNext(Integer[] integers) Observer, как onNext(Integer[] integers)
fromArray() - производит выбросы N. Observable.fromArray(new Integer[]{1, 2, 3}) производит три излучения с обратным onNext(Integer integer) Observer, как onNext(Integer integer)
Оператор inRxJava Just() принимает список аргументов и преобразует элементы в наблюдаемые элементы. Он принимает аргументы от одного до десяти (но в официальном документе говорится, что от одного до девяти, может быть, для конкретного языка).
В отличие от just, From() создает Observable из набора элементов, используя Iterable, что означает, что каждый элемент испускается по одному за раз.
from работ в основном с структурами данных (массивами и итерабельными) и фьючерсами, поэтому полученный Observable будет выделять отдельные элементы из этих структур данных или фьючерсов.
just обрабатывает все как элемент, независимо от того, является ли это элементом массива или целым элементом. Путаница вокруг just порождаются тем, что есть несколько just варианты, которые могут принять до 10 аргументов.
Таким образом, на самом деле вы можете интерпретировать все те just варианты, как они испускают, соответственно, "просто" один элемент или "просто" два элемента, "просто" три элемента и так далее...
Мы можем передать максимум 10 аргументов в just(), в то время как fromArray имеет тип списка.
В то время как внутри просто() вызывается fromArray().
Проверьте ниже код RxJava только для 4 аргументов.
public static <T> Observable<T> just(T item1, T item2, T item3, T item4) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
return fromArray(item1, item2, item3, item4);
}
Оба возвращают один и тот же наблюдаемый объект.