RxJava2（四）创建操作符

创建被观察者的操作符
创建操作符：

private void RxJava2() {

        ObservableSource<T> :Observable数据;
        Ierable<T>  :集合;
        Array[]  :数组;
        Fruture<T> :有返回值的Callable;
        Callback : 线程;

        //从头开始创建一个ObserVable
        Observable.create(ObservableOnSubscribe < T >);

        //只发射第一个发射数据的Observable的全部数据，其他被忽略.包括onError，onComplete
        Observable.amb(Iterable < ObservableSource < T >> sources);
        Observable.ambArray(ObservableSource < T >[]sources);

        //当其中一个Observable发射了数据，通过Function组合每个Observable最新发射的一个数据，然后发射这个组合。
        Observable.combineLatest(ObservableSource < T >[]sources, Function < T, R > func);
        Observable.combineLatest(ObservableSource < T >[]sources, Function < T, R > func,
        int bufferSize);
        Observable.combineLatest(Iterable < ObservableSource < T >> sources, Function < T, R > func);
        Observable.combineLatest(Iterable < ObservableSource < T >> sources, Function < T, R > func,
        int bufferSize)；
        Observable.combineLatest(ObservableSource < T1 > source1, ObservableSource < T2 > source2, BiFunction < T1, T2, R > bifunc);
        //若有异常，延迟它，知道正确的数据发射完成再发射异常。
        Observable.combineLatestDelayError(ObservableSource < T >[]sources, Function < T, R > func);
        Observable.combineLatestDelayError(ObservableSource < T >[]sources, Function < T, R > func,
        int bufferSize);
        Observable.combineLatestDelayError(Iterable < ObservableSource < T >> sources, Function < T, R > func);
        Observable.combineLatestDelayError(Iterable < ObservableSource < T >> sources, Function < T, R > func,
        int bufferSize);

        //按顺序链接多个Observable的数据
        Observable.concat(Iterable < ObservableSource < T >> sources);
        Observable.concatDelayError(Iterable < ObservableSource < T >> sources);
        Observable.concatArray(ObservableSource < T >[]);
        Observable.concatArrayDelayError(ObservableSource < >[]);
        Observable.concatEager(Iterable < ObservableSource < T >> sources);
        Observable.concatEager(ObservableSource < T >[]);
        Observable.concatArrayEager();
        Observable.concatArrayEagerDelayError();

        //一直等待，直到有订阅者，才为每一个订阅者单独创建一个新的Observable，以便包含最新数据
        Observable.defer(Callback < ? extends ObservableSource<? extends T>>callback);

        //发射一个空值
        Observable.empty();
        //不发射值
        Observable.never();
        //发射一个异常
        Observable.error(Throwable throwable);
        Observable.error(Callback < Throwable >);

        //以Iterable，Array，Future，Callable，Publisher为数据来源创建Observable
        Observable.fromIterable(Ierable < T >);
        Observable.fromArray(Array[]);
        //从Fruture的Callable获取数据
        Observable.fromFuture(Fruture < T > frature);
        Observable.fromFuture(Fruture < T > frature, Scheduler scheduler);
        Observable.fromFuture(Fruture < T > frature, long timeout,,TimeUnit unit);
        Observable.fromFuture(Fruture < T > frature, long timeout,,TimeUnit unit, Scheduler
        scheduler);
        Observable.fromCallable(Callback < T > callback);
        //从响应式数据流获取要发射的数据
        Observable.fromPublisher(Publisher < T > publisher);

        //create 每次可以发射多个事件，而 generate 是每次只能发送一个
        //一次连续发射 onNext 和 onComplete/onError 是可以的。如果连续调用多次 onNext 就崩溃了。
        Observable.generate(Consumer < Emitter < T >> generater);
        //initialState表示一个状态，状态不变，不停的发射不停的接收[generate](https://cloud.tencent.com/developer/article/1334651)
        Observable.generate(Callback < S > initialState, BiConsumer < S, Emitter < T >> generater);
      
        //按固定时间间隔发射一个从0开始无限递增的整数序列，制定调度器
        Observable.interval( long peroid, TimeUnit unit);
        Observable.interval( long peroid, TimeUnit unit, Scheduler scheduler);
        //初始延迟initialDely
        Observable.interval( long initialDely, long peroid, TimeUnit unit);
        Observable.interval( long initialDely, long peroid, TimeUnit unit, Scheduler scheduler);

        //创建一个起始值start，发射count次，initialDely，发射周期peroid的Observable
        Observable.intervalRange( long start, long count, long initialDely, long peroid, TimeUnit
        unit);
        Observable.intervalRange( long start, long count, long initialDely, long peroid, TimeUnit
        unit, Scheduler scheduler);

        //将最多4个Obserable发射数据组合成一个，3个重载，参数为1个2个3个
        Observable.merge(Iterable < ObservableSource < T >> sources, int maxCurrentcy,
        int bufferSize);
        Observable.merge(ObservableSource < T >[],int maxCurrentcy, int bufferSize);
        Observable.mergeDelayError(Iterable < ObservableSource < T >> sources, int maxCurrentcy,
        int bufferSize);
        Observable.mergeDelayError(ObservableSource < T >[],int maxCurrentcy, int bufferSize)
        //3个重载，参数为1个2个3个
        Observable.mergeArray( int maxCurrentcy, int bufferSize, ObservableSource<T >[]);
        Observable.mergeArrayDelayError( int maxCurrentcy, int bufferSize, ObservableSource<T >[]);

        //创建一个发射指定值的Observable
        Observable.just(Object item,...);

        //创建一个给定初始整数值start，发射count次，每次start++的Observable
        Observable.range( int start, int count);
        Observable.rangeLong( long start, long count);

        //判断两个Observable是否具有相同的数据序列（相同的数据,顺序,终止状态）
        Observable.sequenceEqual(ObservableSource < T1 > source1, ObservableSource < T2 > source2);
        Observable.sequenceEqual(ObservableSource < T1 > source1, ObservableSource < T2 > source2,
        int bufferSize);
        Observable.sequenceEqual(ObservableSource < T1 > source1, ObservableSource < T2 > source2, BiFunction < T1, T2, R > bifunc);
        Observable.sequenceEqual(ObservableSource < T1 > source1, ObservableSource < T2 > source2, BiPredicate < T1, T2 > biPredicate);

        Observable.switchOnNext(Iterable < ObservableSource < T >> sources);
        Observable.switchOnNext(ObservableSource < ObservableSource < T >> [],int bufferSize)
        Observable.switchOnNextDelayError(ObservableSource < ObservableSource < T >> sources);

        //创建一个在给定的延时之后发射数据项为0的Observable<Long>，指定调度器
        Observable.timer( long delay, TimeUnit unit);
        Observable.timer( long delay, TimeUnit unit, Scheduler scheduler);

        //创建一个只在Observable生命周期存在的资源，当Observable终止时这个资源会被自动释放。创建资源，Observable，释放资源
        Observable.using(
                Callback <D> resourceSupplier, Function < D, ObservableSource < T >> sourceSupplier,Consumer<T> dispose);

        Observable.wrap(ObservableSource < ? extends T > source);

        //按顺序依次组合多个Observable的数据项应用一个函数，直到数据项最少的那个Observable用完数据项为止不再组合，然后发射组合项
        Observable.zip(Iterable < ObservableSource < T >> sources, Function < T, R >);
        Observable.zip(ObservableSource < ObservableSource < T >> sources);
        Observable.zipArray(Function < Object[],R >,boolean delayError,
        int bufferSize, ObservableSource<? extends T >);
        Observable.zipIterable(Iterable < ObservableSource < T >> sources, Function < Object[],R >,
        boolean delayError, int bufferSize);
    }

1.create 从头开始创建一个ObserVable。

        //创建被观察者
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) {
                //发射数据，先检查订阅者是否取消订阅
                if (!emitter.isDisposed()){
                    emitter.onNext("Hello World");
                }
                emitter.onComplete();
            }
            //订阅给观察者，接收数据
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.d(TAG, "accept: onNext = " + s);
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
            //错误
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.d(TAG, "accept: onError = " + throwable.getMessage());
            }
            //执行完成
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "run: onComplete");
            }
        });

2.just 创建一个发射指定值的Observable。

        //创建被观察者
        Observable.just("qwe","asd","zxc")
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.d(TAG, "accept: onNext = " + s);
                        Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
                    }
                });

输出结果：
accept: onNext = qwe
accept: onNext = asd
accept: onNext = zxc

3.from 可以将其他种类对象和数据如：Array，Iterable，Future转换为Observable。以便我们在数据流的整个生命周期使用统一的操作符来管理他们。
（1）fromArray

    Observable.fromArray("qwe", "asd", "zxc")
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.d(TAG, "accept: onNext = " + s);
                        Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
                    }
                });

输出结果：
accept: onNext = qwe
accept: onNext = asd
accept: onNext = zxc

（2）fromIterable

List<String> strList = new ArrayList<>();
        strList.add("qwe");
        strList.add("asd");
        strList.add("zxc");
        Observable.fromIterable(strList)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.d(TAG, "accept: onNext = " + s);
                        Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
                    }
                });

输出结果：
accept: onNext = qwe
accept: onNext = asd
accept: onNext = zxc

（3）fromFuture 从Future的Callable获取数据

//买10斤萝卜5秒
        Callable callable1 = new Callable() {

            @Override
            public String call() throws Exception {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "买10斤萝卜";
            }
        };
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future1 = executorService.submit(callable1);
        Observable.fromFuture(future1)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.d(TAG, "accept: future1 " + s);
                    }
                });
        try {
            Log.d(TAG, "返回值: 5秒 " + future1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

输出结果：
返回值: 5秒 买10斤萝卜
accept: future1被发射的值： 买10斤萝卜

（4）fromPublish    从响应式数据流获取要发射的数据，Flowable 实现了 Publisher

Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                emitter.onNext("123");
                emitter.onNext("456");
                emitter.onNext("789");
            }
        },BackpressureStrategy.BUFFER);
        Observable.fromPublisher(flowable).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                
            }
        });

4.combineLatest 当其中一个Observable发射了数据，通过Function组合每个Observable最新发射的一个数据，然后发射这个组合。

Observable<String> ob1 = Observable.just("name");
        Observable<String> ob2 = Observable.just("password");
        Observable.combineLatest(ob1, ob2, new BiFunction<String, String, Object>() {
            @Override
            public Object apply(String s1, String s2) {
                return null;
            }
        });

defer 一直等待，直到有订阅者，才为每一个订阅者单独创建一个新的Observable，以确保发射的是最新的数据。

Observable observable = Observable.defer(new Callable<ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> call() throws Exception {
                return Observable.just("qwe","asd","zxc");
            }
        });
        observable.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, "accept: " + s);
            }
        });

6.intenterval 按固定时间间隔发射一个从0开始无限递增的整数序列。

Observable.interval(5,TimeUnit.MILLISECONDS)
               .take(10)
               .subscribe(new Consumer<Long>() {
                   @Override
                   public void accept(Long aLong) throws Exception {
                       Log.d(TAG, "accept: " + aLong);
                   }
               });

输出结果：
accept: 0
accept: 1
accept: 2
accept: 3
accept: 4
accept: 5
accept: 6
accept: 7
accept: 8
accept: 9

7. range(int start,int count) 创建一个给定初始整数值start，发射count次，每次start++的Observable。

Observable.range(3,4)
               .subscribe(new Consumer<Integer>() {
                   @Override
                   public void accept(Integer integer) throws Exception {
                       Log.d(TAG, "accept: " + integer);
                   }
               });

输出结果：
accept: 3
accept: 4
accept: 5
accept: 6

8.intentervalRange(start,count,delay,interval,时间单位) 创建一个起始值start，发射count次，延迟delay，发射周期interval的Observable。

final long start = System.currentTimeMillis();
        Log.d(TAG, "初始时间: " + 0);
        //从3开始 发射4次 延迟50毫秒发射 发射周期100毫秒
       Observable.intervalRange(3,4,1000,1000,TimeUnit.MILLISECONDS)
               .subscribe(new Consumer<Long>() {
                   @Override
                   public void accept(Long aLong) throws Exception {
                       Log.d(TAG, "收到值:" + aLong + "  时间:" + (System.currentTimeMillis() - start));
                   }
               });

输出结果：
初始时间: 0
收到值:3 时间:1025
收到值:4 时间:2032
收到值:5 时间:3027
收到值:6 时间:4031

9.timer 创建一个给定延迟后才发射一个特殊值0的Observable。

final long start = System.currentTimeMillis();
        Log.d(TAG, "初始时间: " + 0);
       Observable.timer(2,TimeUnit.SECONDS)
               .subscribe(new Consumer<Long>() {
                   @Override
                   public void accept(Long aLong) throws Exception {
                       Log.d(TAG, "收到值:" + aLong + "  时间:" + (System.currentTimeMillis() - start));
                       Observable.just(1,2,3)
                               .subscribe(new Consumer<Integer>() {
                                   @Override
                                   public void accept(Integer integer) throws Exception {
                                       Log.d(TAG, "延迟2秒后，收到到0这个值，再自定义发射数据" + integer);
                                   }
                               });
                   }
               });

输出结果：
初始时间: 0
收到值:0 时间:2031
延迟2秒后，收到到0这个值，再自定义发射数据1
延迟2秒后，收到到0这个值，再自定义发射数据2
延迟2秒后，收到到0这个值，再自定义发射数据3

10.concat    按顺序链接多个Observable的数据

Observable<String> ob1 = Observable.just("name");
        Observable<String> ob2 = Observable.just("password");
        Observable.concat(ob1,ob2)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        
                    }
                });

11.generate

//Callable<Integer>返回一个状态，此处返回0，每次发射一个数据，currentStata++，直到currentStata>=10结束，
        Observable.generate(new Callable<Integer>() {
            @Override
            public Integer call() {
                return 0;
            }
        }, new BiConsumer<Integer, Emitter<String>>() {
            @Override
            public void accept(Integer currentStata, Emitter<String> emitter) throws Exception {
                if (currentStata < 10){
                    emitter.onNext("songfeng");
                }else {
                    emitter.onComplete();
                }
                currentStata++;
            }
        }).subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, "accept: " + s);
            }
        });