rxjava :创建操作符 : create / fromArray / just / fromIterable

create

create(ObservableOnSubscribe source)

@Test
public void create() {
    Disposable disposable = Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onComplete();
        }
    }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            System.out.println("integer==============" + integer);
        }
    });
}
//integer==============1
//integer==============2
//integer==============3

fromArray

fromArray(T… items)

@Test
public void fromArray1() {
    int[] arrays = {1, 2, 3};
    //接收一个数组，从数组中一个一个取出来发射。
    //上游数组 ，下游也数组
    Disposable disposable = Observable.fromArray(arrays)
            .subscribe(new Consumer<int[]>() {
                @Override
                public void accept(int[] ints) throws Exception {
                    for (int anInt : ints) {
                        System.out.println("int========" + anInt);
                    }
                }
            });
}
//int========1
//int========2
//int========3




@Test
public void fromArray2() {
   Integer[] arrays = {1, 2, 3};
   //接收一个数组，从数组中一个一个取出来发射。
    //上游数组 ，下游直接遍历
   Disposable disposable = Observable.fromArray(arrays)
           .subscribe(new Consumer<Integer>() {
               @Override
               public void accept(Integer integer) throws Exception {
                   System.out.println("integer=========" + integer);
               }
           });
}
//integer=========1
//integer=========2
//integer=========3

just

just(T item)
…
just(T item1, T item2, T item3 … T item10)

参数为1到10个

@Test
public void just1() {
    int[] arrays = {1, 2, 3};
    //just(T item)
    //上游数组 ，下游也数组
    Disposable disposable = Observable.just(arrays)
            .subscribe(new Consumer<int[]>() {
                @Override
                public void accept(int[] ints) throws Exception {
                    for (int anInt : ints) {
                        System.out.println("int========" + anInt);
                    }
                }
            });
}
//int========1
//int========2
//int========3





@Test
public void just2() {
    int[] arrays1 = {1, 2, 3};
    int[] arrays2 = {4, 5, 6};
    //just(T item1, T item2)   ,  最多十个
    //接收1个以上,10个以下的参数，然后逐个发射。
    Disposable disposable = Observable.just(arrays1, arrays2)
            .subscribe(new Consumer<int[]>() {
                @Override
                public void accept(int[] ints) throws Exception {
                    for (int anInt : ints) {
                        System.out.println("int========" + anInt);
                    }
                }
            });
}
//int========1
//int========2
//int========3
//int========4
//int========5
//int========6

fromIterable

fromIterable(Iterable<? extends T> source)

@Test
public void fromIterable() {
    Integer[] arrays = {1, 2, 3};

//        List<Integer> list = Arrays.asList(arrays);
    List<Integer> list = new ArrayList<>(Arrays.asList(arrays));
    
    Disposable disposable = Observable.fromIterable(list)
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println("integer============" + integer);
                }
            });
}
//integer============1
//integer============2
//integer============3