RxJava2.0基础入门以及常见操作符详解

RxJava基础入门

如何实现一个最简单的RxJava代码

Demo下载地址 https://github.com/findandroidviewbyid/RxJavaDemo.git

  1. RxJava引入

    compile "io.reactivex.rxjava2:rxjava:2.1.12"

  2. 实现RxJava代码

    引入了RxJava之后我们就可以正常的编辑代码了,首先实现一个最简单的RxJava的代码片段,具体代码如下

    Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            emitter.onNext("创建一个RxJava示例");
            emitter.onComplete();
        }
    });
    
    Observer observer =new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onSubscribe: "+d );
        }
    
        @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext: "+s );
        }
    
        @Override
        public void onError(Throwable e) {
            e.printStackTrace();
            Log.e(TAG, "onError: "+e );
        }
    
        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete: " );
        }
    };
    Log.e(TAG, "onCreate: 订阅之前" );
    stringObservable.subscribe(observer);
    Log.e(TAG, "onCreate: 订阅之后" );
    
  3. 控制台打印如下

`

04-15 23:46:08.558 23259-23259/com.example.rxjavaandretrofit E/MainActivity: onCreate: 订阅之前

04-15 23:46:08.558 23259-23259/com.example.rxjavaandretrofit E/MainActivity: onSubscribe: null


04-15 23:46:08.559 23259-23259/com.example.rxjavaandretrofit E/MainActivity: onNext: 创建一个RxJava示例

04-15 23:46:08.559 23259-23259/com.example.rxjavaandretrofit E/MainActivity: onComplete: 
04-15 23:46:08.559 23259-23259/com.example.rxjavaandretrofit E/MainActivity: onCreate: 订阅之后

`

由上面的代码以及打印我们可以很清楚的看到当被订阅者(stringObservable)被订阅时(stringObservable.subscribe(observer))被订阅者向下游的订阅者发送了一个emitter.onNext(“创建一个RxJava示例”)的事件,这个时候订阅者接受到这个事件就可以根据自己的需求处理该事件了

上述的代码分别是运行在哪里?我们如何去改变他们所运行的线程

  1. 我们在上述的代码中的的关键地方分别添加上log打印当前的线程名

`

Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            emitter.onNext("创建一个RxJava示例");
            emitter.onComplete();
            Log.e(TAG, "subscribe: "+Thread.currentThread().getName() );
        }
    });


    @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext: "+s );
            Log.e(TAG, "onNext: "+Thread.currentThread().getName() );

        }

`

`

04-16 00:06:50.463 28545-28545/com.example.rxjavaandretrofit E/MainActivity: onNext: main
04-16 00:06:50.463 28545-28545/com.example.rxjavaandretrofit E/MainActivity: onComplete: 
04-16 00:06:50.463 28545-28545/com.example.rxjavaandretrofit E/MainActivity: subscribe: main

`

敲黑板,请注意

通过打印我们可以清楚的看到当前是处于一个主线程的,那么我们是否可以断定默认情况下观察者和被观察者是处于UI线程中呢,当然我们不能这样武断的说,那么 让我们创建一个子线程然后在子线程中创建观察者和被观察者来试试
`

new Thread(new Runnable() {
        @Override
        public void run() {
            Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                    emitter.onNext("创建一个RxJava示例");
                    emitter.onComplete();
                    Log.e(TAG, "subscribe: "+Thread.currentThread().getName() );
                }
            });

            Observer observer =new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.e(TAG, "onSubscribe: "+d );
                }

                @Override
                public void onNext(String s) {
                    Log.e(TAG, "onNext: "+s );
                    Log.e(TAG, "onNext: "+Thread.currentThread().getName() );

                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    Log.e(TAG, "onError: "+e );
                }

                @Override
                public void onComplete() {
                    Log.e(TAG, "onComplete: " );
                }
            };
            Log.e(TAG, "onCreate: 订阅之前" );
            stringObservable.subscribe(observer);
            Log.e(TAG, "onCreate: 订阅之后" );
        }
    }).start();

`
上面我们仅仅是在原有的基础上将创建和订阅的过程添加到一个子线程中去了,下面我们看一下打印

`

04-16 00:10:51.036 29541-29565/com.example.rxjavaandretrofit E/MainActivity: onCreate: 订阅之前
04-16 00:10:51.036 29541-29565/com.example.rxjavaandretrofit E/MainActivity: onSubscribe: null
04-16 00:10:51.036 29541-29565/com.example.rxjavaandretrofit E/MainActivity: onNext: 创建一个RxJava示例
04-16 00:10:51.036 29541-29565/com.example.rxjavaandretrofit E/MainActivity: onNext: Thread-3
04-16 00:10:51.036 29541-29565/com.example.rxjavaandretrofit E/MainActivity: onComplete: 
04-16 00:10:51.036 29541-29565/com.example.rxjavaandretrofit E/MainActivity: subscribe: Thread-3
04-16 00:10:51.036 29541-29565/com.example.rxjavaandretrofit E/MainActivity: onCreate: 订阅之后

`
从打印中我们可以清楚的看到观察者和被观察者都是运行在子线程中的,当然这样我们现在还不能说他们是默认运行在观察者和被观察者创建的线程中,因为我们还没有尝试过将二者分别在两个线程中创建会有什么效果,下面我就不将代码写出来了,直接把结论告诉大家其实观察者和被观察者创建的线程并不会影响他们所运行的线程,但是观察者在那个线程中订阅观察者会让二者共同运行在该线程.

如何更改观察者和订阅者之间线程

对RxJava有些了解的同学已经知道可以使用subscribeOn()和observeOn()来实现线程的 切换,不过你现在去试试发现不知道使用哪个参数让他们运行在主线程中吧(现在讨论在子线程订阅的情况,在该中情况下二者默认运行在订阅线程所在的线程中)其实这就需要我们引入新的库
implementation ‘io.reactivex.rxjava2:rxandroid:2.0.2’
当这个库引入的时候我们就可以随心所欲的更换我们运行的线程了,具体的代码示例如下

`

new Thread(new Runnable() {
        @Override
        public void run() {
            Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                    emitter.onNext("创建一个RxJava示例");
                    emitter.onComplete();
                    Log.e(TAG, "subscribe: "+Thread.currentThread().getName() );
                }
            });

            Observer observer =new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.e(TAG, "onSubscribe: "+d );
                }

                @Override
                public void onNext(String s) {
                    Log.e(TAG, "onNext: "+s );
                    Log.e(TAG, "onNext: "+Thread.currentThread().getName() );

                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    Log.e(TAG, "onError: "+e );
                }

                @Override
                public void onComplete() {
                    Log.e(TAG, "onComplete: " );
                }
            };
            Log.e(TAG, "onCreate: 订阅之前" );
            stringObservable
                    //运行在子线程中
                    .subscribeOn(Schedulers.io())
                    //运行在UI线程中
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(observer);
            Log.e(TAG, "onCreate: 订阅之后" );
        }
    }).start();

`

前面说了我们在那个线程中订阅,那么观察者者和被观察者都是处于该线程,但是通过我们.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())这两步的操作我们的观察者就运行在主线程了,而被观察者就运行在子线程了(这个子线程可不是我们 new Thread创建的线程哦,还记得我们new Thread创建的线程的name是 Thread-3 吧)
`

04-16 00:35:09.696 5374-5421/com.example.rxjavaandretrofit E/MainActivity: onCreate: 订阅之前
04-16 00:35:09.703 5374-5421/com.example.rxjavaandretrofit E/MainActivity: onSubscribe: 0
04-16 00:35:09.704 5374-5421/com.example.rxjavaandretrofit E/MainActivity: onCreate: 订阅之后
04-16 00:35:09.705 5374-5424/com.example.rxjavaandretrofit E/MainActivity: subscribe: RxCachedThreadScheduler-1
04-16 00:35:09.718 5374-5374/com.example.rxjavaandretrofit E/MainActivity: onNext: 创建一个RxJava示例
04-16 00:35:09.718 5374-5374/com.example.rxjavaandretrofit E/MainActivity: onNext: main
04-16 00:35:09.718 5374-5374/com.example.rxjavaandretrofit E/MainActivity: onComplete: 

`

RxJava的其他的一些常见的操作符

RxJava的操作符分类

  1. 创建型的操作符 Creating Observables

a.create 上文使用的均为Create操作符

`

servableOnSubscribe<String>() {
                @Override
                public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                    emitter.onNext("创建一个RxJava示例");
                    emitter.onComplete();
                    Log.e(TAG, "subscribe: "+Thread.currentThread().getName() );
                }
            });

            Observer observer =new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.e(TAG, "onSubscribe: "+d );
                }

                @Override
                public void onNext(String s) {
                    Log.e(TAG, "onNext: "+s );
                    Log.e(TAG, "onNext: "+Thread.currentThread().getName() );

                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    Log.e(TAG, "onError: "+e );
                }

                @Override
                public void onComplete() {
                    Log.e(TAG, "onComplete: " );
                }
            };
            Log.e(TAG, "onCreate: 订阅之前" );
            stringObservable
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(observer);
            Log.e(TAG, "onCreate: 订阅之后" );

`

b.Just 该操作符更像是create的一种简写,他可以发送基本数据类型也可以发送其他数据类型,但是他最多接收10个参数然后依次的发送给观察者,订阅者接收到的是发送的数据本身,注意和下文的FromArray做对比
`

            ArrayList<Integer> integers =new ArrayList<>(500);
            for (int i = 0; i < 500; i++) {
                integers.add(i);
            }
            Observable.just(integers)
                    .subscribe(new Observer<ArrayList<Integer>>() {
                        @Override
                        public void onSubscribe(Disposable d) {
                            Log.e(TAG, "onSubscribe: "+d );
                        }

                        @Override
                        public void onNext(ArrayList<Integer> integers) {
                            for (Integer integer1 : integers) {
                                Log.e(TAG, "onNext: "+integer1 );
                            }
                        }

                        @Override
                        public void onError(Throwable e) {
                            e.printStackTrace();
                            Log.e(TAG, "onError: "+e );
                        }

                        @Override
                        public void onComplete() {
                            Log.e(TAG, "onComplete: " );
                        }
                    });

`

c.From 这里只简单的讲一下fromArray与just的区别 第一点fromArray可以接受N个参数(just最多只能接受10个),然后分别发送给订阅者.第二点如果说Observable.just(new String[]{“”,”“,”“}).那么.next接收到的是String[]的地址,但是如果是 Observable.fromArray(new String[]{“1”,”3”,”5”})那么.next会根据数组的长度返回每一个具体的值
`

//fromArray
Observable.fromArray(new String[]{"1","3","5"}).subscribe(new Consumer<String>() {
        @Override
        public void accept(String integer) throws Exception {
            Log.e(TAG, "from accept: "+integer );
        }
    });

04-16 02:05:01.471 30412-30412/com.example.rxjavaandretrofit E/MainActivity: from accept: 1
04-16 02:05:01.471 30412-30412/com.example.rxjavaandretrofit E/MainActivity: from accept: 3
04-16 02:05:01.471 30412-30412/com.example.rxjavaandretrofit E/MainActivity: from accept: 5

//just
Observable.just(new String[]{"1","3","5"})
                    .subscribe(new Consumer<String[]>() {
                        @Override
                        public void accept(String[] strings) throws Exception {
                            Log.e(TAG, "accept: "+strings );
                        }
                    });

04-16 02:05:01.470 30412-30412/com.example.rxjavaandretrofit E/MainActivity: accept: [Ljava.lang.String;@63f8080

`

d.Interval 每隔一定时间发射一次,并且递增.从代码和打印中我们可以看到第一个参数是订阅之后多久发射第一次,第二个参数表示接下来每隔多久发射一次

`

Log.e(TAG, "RxjavaInterval: " );
    Observable.interval(1,2,TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) throws Exception {
            Log.e(TAG, "accept: "+aLong );
        }
    });



    04-16 02:17:19.581 1536-1536/com.example.rxjavaandretrofit E/MainActivity: RxjavaInterval: 
    04-16 02:17:20.587 1536-1564/com.example.rxjavaandretrofit E/MainActivity: accept: 0
    04-16 02:17:22.587 1536-1564/com.example.rxjavaandretrofit E/MainActivity: accept: 1
    04-16 02:17:24.588 1536-1564/com.example.rxjavaandretrofit E/MainActivity: accept: 2
    04-16 02:17:26.588 1536-1564/com.example.rxjavaandretrofit E/MainActivity: accept: 3
    04-16 02:17:28.587 1536-1564/com.example.rxjavaandretrofit E/MainActivity: accept: 4
    04-16 02:17:30.588 1536-1564/com.example.rxjavaandretrofit E/MainActivity: accept: 5
    04-16 02:17:32.587 1536-1564/com.example.rxjavaandretrofit E/MainActivity: accept: 6

`

e.Range 函数原型range(n ,m) 其实range就是依次发射从n到n+m-1的数据例如下文的range(5,5)就是依次发射了5,6,7,8,9五个数据项

`

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

04-16 13:26:57.142 1896-1896/com.example.rxjavaandretrofit E/MainActivity: accept:--- 5
04-16 13:26:57.142 1896-1896/com.example.rxjavaandretrofit E/MainActivity: accept:--- 6
04-16 13:26:57.142 1896-1896/com.example.rxjavaandretrofit E/MainActivity: accept:--- 7
04-16 13:26:57.142 1896-1896/com.example.rxjavaandretrofit E/MainActivity: accept:--- 8
04-16 13:26:57.142 1896-1896/com.example.rxjavaandretrofit E/MainActivity: accept:--- 9

`

f.Defer 直到有观察者订阅时才创建Observable,并且为每个观察者创建一个新的Observable
`

Observer<Integer> observer = new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onSubscribe: "+d );
        }

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

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onError: " );
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete: " );
        }//
    };
    Observable<Integer> defer = Observable.defer(new Callable<ObservableSource<Integer>>() {
        @Override
        public ObservableSource<Integer> call() throws Exception {
            Log.e(TAG, "call: " );
            return Observable.range(1, 5);
        }
    });
    defer.subscribe(observer);

04-16 14:15:13.742 2973-2973/com.example.rxjavaandretrofit E/MainActivity: onSubscribe: 0
04-16 14:15:13.742 2973-2973/com.example.rxjavaandretrofit E/MainActivity: onNext: 1
04-16 14:15:13.742 2973-2973/com.example.rxjavaandretrofit E/MainActivity: onNext: 2
04-16 14:15:13.742 2973-2973/com.example.rxjavaandretrofit E/MainActivity: onNext: 3
04-16 14:15:13.742 2973-2973/com.example.rxjavaandretrofit E/MainActivity: onNext: 4
04-16 14:15:13.742 2973-2973/com.example.rxjavaandretrofit E/MainActivity: onNext: 5
04-16 14:15:13.742 2973-2973/com.example.rxjavaandretrofit E/MainActivity: onComplete: 

`

g.Timer 创建一个被观察者,并在指定时间后发送一个事件,可以和interval比较

`

//延时1s后发射一个事件
    Observable.timer(1,TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) throws Exception {
            Log.e(TAG, "accept: "+aLong );
        }
    });

`

h. Repeat 重复的发送指定的事件,下文的timer配合repeat即可实现循环发送的效果(发送的是同一事件)

`

Observable.timer(1,TimeUnit.SECONDS).repeat().subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) throws Exception {
            Log.e(TAG, "accept: "+aLong );
        }
    });

04-16 14:31:21.172 3289-3303/com.example.rxjavaandretrofit MainActivity: accept: 0
04-16 14:31:22.182 3289-3304/com.example.rxjavaandretrofit E/MainActivity: accept: 0
04-16 14:31:23.172 3289-3303/com.example.rxjavaandretrofit E/MainActivity: accept: 0
04-16 14:31:24.182 3289-3304/com.example.rxjavaandretrofit E/MainActivity: accept: 0

`

其他 Start Enpty/Never/Throw

  1. 转换型的操作符 Transforming Observables

Map 将数据进行转换然后发射出去,下文的代码中我们使用了两次map分别在第一次的时候将字符串123转换成integer类型并加上7得出结果130,然后将130转化成字符串并在结尾加上1最终结果为1301,看一下打印是否和我们预测的一致

`

Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            emitter.onNext("123");
        }
    })
    //将string转换成integer类型并加上7
    .map(new Function<String, Integer>() {
        @Override
        public Integer apply(String s) throws Exception {

            return Integer.parseInt(s)+7;
        }
    })
    //将上面的integer类型转换成string类型并在结尾加上1
    .map(new Function<Integer, String>() {
        @Override
        public String apply(Integer integer) throws Exception {
            return integer+"1";
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            Log.e(TAG, "accept: " +s);
        }
    });

04-16 14:43:29.702 3565-3565/com.example.rxjavaandretrofit E/MainActivity: accept: 1301

`

GroupBy分组顾名思义就是将数据进行分组,先来看一个简单的例子,从例子中我们可以明确的看到如何进行分组,和最后分组的结果

`

 //just 发射数据
    Observable.just("1","2","4","5","7","8")
            .groupBy(new Function<String, Integer>() {
                @Override
                public Integer apply(String s) throws Exception {
                    //分组规则
                    if (Integer.parseInt(s)>4){
                        return 0;
                    }else {
                        return 1;
                    }
                }
            }).subscribe(new Observer<GroupedObservable<Integer, String>>() {
        @Override
        public void onSubscribe(Disposable d) {

        }
        //此处的onNext返回的是一个Observable
        @Override
        public void onNext(final GroupedObservable<Integer, String> integerStringGroupedObservable) {
            integerStringGroupedObservable.subscribe(new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(String s) {
                    //可以通过
                    Log.e(TAG, "onNext: Group "+integerStringGroupedObservable.getKey()+"data"+s );
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    });


04-16 15:36:06.902 4132-4132/com.example.rxjavaandretrofit E/MainActivity: onNext: Group 1data1
04-16 15:36:06.902 4132-4132/com.example.rxjavaandretrofit E/MainActivity: onNext: Group 1data2
04-16 15:36:06.902 4132-4132/com.example.rxjavaandretrofit E/MainActivity: onNext: Group 1data4
04-16 15:36:06.902 4132-4132/com.example.rxjavaandretrofit E/MainActivity: onNext: Group 0data5
04-16 15:36:06.902 4132-4132/com.example.rxjavaandretrofit E/MainActivity: onNext: Group 0data7
04-16 15:36:06.902 4132-4132/com.example.rxjavaandretrofit E/MainActivity: onNext: Group 0data8

`

buffer 我们还是通过例子来解释,可以看到buffer就是将每组数据按要求分成若干组,然后发射给观察者

`

        Observable
            //发射从1到1+5-1的数据项
            .range(1,5)
            //使用buffer的形式,每个里面存3个数据
            .buffer(3)
            //订阅
            .subscribe(new Consumer<List<Integer>>() {
        @Override
        public void accept(List<Integer> integers) throws Exception {
            Log.e(TAG, "accept: "+integers );
        }
    });

04-16 15:40:29.492 4346-4346/com.example.rxjavaandretrofit E/MainActivity: accept: [1, 2, 3]
04-16 15:40:29.492 4346-4346/com.example.rxjavaandretrofit E/MainActivity: accept: [4, 5]

`

scan 将数据进行一个累加的操作

`

    Observable
            //取1到1+5-1的数
            .range(1,5)
            //scan就是将数据进行一个累加
            .scan(new BiFunction<Integer, Integer, Integer>() {
        @Override
        public Integer apply(Integer integer, Integer integer2) throws Exception {
            //integer是前面的数据累加的和
            //integer2是当前要加上的数据
            return integer+integer2;
        }
    }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });
04-16 15:48:56.532 4529-4529/com.example.rxjavaandretrofit E/MainActivity: accept: 1
04-16 15:48:56.532 4529-4529/com.example.rxjavaandretrofit E/MainActivity: accept: 3
04-16 15:48:56.532 4529-4529/com.example.rxjavaandretrofit E/MainActivity: accept: 6
04-16 15:48:56.532 4529-4529/com.example.rxjavaandretrofit E/MainActivity: accept: 10
04-16 15:48:56.532 4529-4529/com.example.rxjavaandretrofit E/MainActivity: accept: 15

`

  1. 过滤型的操作符 Flitering Observables

    Debounce 在一个数据列表中如果空闲m之后没有操作那么发送该数据,那么从下面的例子可以清楚的看到两秒钟之内都是空闲的才会发射数据到观察者,也就是只有当i==9的时候才会发射一次,但是在这里还有一个问题,如果是debounce(1,TimeUnit.SECONDS)那么数据的发射可能就和我们预想的不一样了,下游观察者接收到的数据可能每一次都不一致,这里主要是由于我们休眠的一秒有可能存在休眠时间超过一秒或者少于一秒的情况导致的,

`

    new Thread(new Runnable() {
        @Override
        public void run() {
            Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                    for (int i = 0; i < 10; i++) {
                        //休眠1s然后发射数据,那么就会只有9这个数据才会被接收者接收到
                        Thread.sleep(1000);
                        emitter.onNext(i);
                    }
                }
            }).debounce(2, TimeUnit.SECONDS).subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.e(TAG, "accept: " + integer);
                }
            });
        }
    }).start();

04-16 16:25:39.892 5002-5017/com.example.rxjavaandretrofit E/MainActivity: accept: 9

`
Distinct 去除重复的数据项,从下面的代码中我们可以清楚的看到distinct去除l重复数据

`

    Observable
            //准备发射1 2 3 1 3 1这6个数据
            .just(1,2,3,1,3,1)
            //去重操作
            .distinct()
            .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            //理论上应该只有1,2,3这三个数据
            Log.e(TAG, "accept: "+integer );
        }
    });

04-16 16:36:59.712 5069-5069/com.example.rxjavaandretrofit E/MainActivity: accept: 1
04-16 16:36:59.712 5069-5069/com.example.rxjavaandretrofit E/MainActivity: accept: 2
04-16 16:36:59.712 5069-5069/com.example.rxjavaandretrofit E/MainActivity: accept: 3

`
ElementAt 取出指定位置的数据,其以0开始

`

    Observable
            .just(1,3,4,6)
            //elementat取出第二个数据(just中参数以1开始,但是elsmentAt中以0开始)
            .elementAt(2)
            .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            //猜测结果为 4
            Log.e(TAG, "accept: "+integer );
        }
    });

04-16 16:41:44.732 5203-5203/com.example.rxjavaandretrofit E/MainActivity: accept: 4

`
Filter

`

 Observable.just(1,3,4,6,78).filter(new Predicate<Integer>() {
        @Override
        public boolean test(Integer integer) throws Exception {
            //指定过滤的条件 大于3的才会被观察者接收到
            return integer>3;
        }
    }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });


04-16 16:47:13.822 5313-5313/com.example.rxjavaandretrofit E/MainActivity: accept: 4
04-16 16:47:13.822 5313-5313/com.example.rxjavaandretrofit E/MainActivity: accept: 6
04-16 16:47:13.822 5313-5313/com.example.rxjavaandretrofit E/MainActivity: accept: 78

`
First

`

    Observable.just(1,23,4,56,23)
            //取第一个数据  也就是1
            .first(12)
            .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });

04-16 16:54:54.452 5659-5659/? E/MainActivity: accept: 1

`
ignoreElements 忽略数据项如果没有异常回调onComplete如果存在异常回调onError

`

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 3; i++) {
                emitter.onNext(i);
            }
            throw new IOException(){};
        }
    })
            .ignoreElements()
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onComplete() {

                }

                @Override
                public void onError(Throwable e) {
                    Log.e(TAG, "onError: " );
                }
            });

04-16 17:01:03.222 5936-5936/com.example.rxjavaandretrofit E/MainActivity: onError: 

`
Last 取最后一位的数据项发送给观察者

`

     Observable.just(1,3,5,7,2,1)
            //取最后一个数据 猜测为1
            .last(100)
            .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });
04-16 17:04:13.162 5995-5995/com.example.rxjavaandretrofit E/MainActivity: accept: 1


Sample 取样操作符,每隔一定的时间向数据列表中取一个数据发送到观察者

   Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 20; i++) {
                Thread.sleep(1000);
                emitter.onNext(i);
            }
        }
    }).sample(2,TimeUnit.SECONDS).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });

04-16 17:18:41.812 7377-7377/com.example.rxjavaandretrofit E/MainActivity: accept: 0
04-16 17:18:43.812 7377-7377/com.example.rxjavaandretrofit E/MainActivity: accept: 2
04-16 17:18:45.812 7377-7377/com.example.rxjavaandretrofit E/MainActivity: accept: 4
04-16 17:18:47.802 7377-7377/com.example.rxjavaandretrofit E/MainActivity: accept: 6

`
Skip 跳过最开始的指定的个数的数据

`

Observable.just(1,3,5,77,82)
    //跳过前两项数据  那么猜测返回的数据是5 77 82
    .skip(2)
    .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });

04-16 17:22:06.042 7441-7441/com.example.rxjavaandretrofit E/MainActivity: accept: 5
04-16 17:22:06.042 7441-7441/com.example.rxjavaandretrofit E/MainActivity: accept: 77
04-16 17:22:06.042 7441-7441/com.example.rxjavaandretrofit E/MainActivity: accept: 82

`

SkipLast 使用方法和Skip一样,只不过跳过的是以结尾往前的数据项

`

Observable.just(1,3,5,77,82).skipLast(3).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });
04-16 17:25:28.402 7555-7555/com.example.rxjavaandretrofit E/MainActivity: accept: 1
04-16 17:25:28.402 7555-7555/com.example.rxjavaandretrofit E/MainActivity: accept: 3

`

Take 取开头的规定个数的数据项

`

Observable.just(1,32,43,53,5).take(3).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });


04-16 17:31:19.642 7729-7729/com.example.rxjavaandretrofit E/MainActivity: accept: 1
04-16 17:31:19.642 7729-7729/com.example.rxjavaandretrofit E/MainActivity: accept: 32
04-16 17:31:19.642 7729-7729/com.example.rxjavaandretrofit E/MainActivity: accept: 43

`

TakeLast 取后面的规定位数的数据项

`

Observable.just(1,32,43,53,5).takeLast(3).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });

04-16 17:29:47.412 7671-7671/com.example.rxjavaandretrofit E/MainActivity: accept: 43
04-16 17:29:47.412 7671-7671/com.example.rxjavaandretrofit E/MainActivity: accept: 53
04-16 17:29:47.412 7671-7671/com.example.rxjavaandretrofit E/MainActivity: accept: 5

`

  1. 组合型的操作符 Combining Observables

zip zip操作符是将两个被观察者的数据根据新建的规则合并并发送出去,注意的是两者合并的时候会以最少的数据项合并,例如下文的just1中只有3个数据项,just中有5个数据项,那么合并之后的观察者能够接收到的也就只有3个数据项,如果说合并出现了异常那么就直接停止并回调onError函数

`

    Observable<Integer> just = Observable.just(1, 32, 55, 455, 46);
    Observable<String> just1 = Observable.just("a", "b", "c");
    Observable.zip(just, just1, new BiFunction<Integer, String, String>() {
        @Override
        public String apply(Integer integer, String s) throws Exception {

            return s+integer;
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            Log.e(TAG, "accept: "+s );
        }
    });

04-16 19:14:08.792 7943-7943/com.example.rxjavaandretrofit E/MainActivity: accept: a1
04-16 19:14:08.792 7943-7943/com.example.rxjavaandretrofit E/MainActivity: accept: b32
04-16 19:14:08.792 7943-7943/com.example.rxjavaandretrofit E/MainActivity: accept: c55

`

merge 将两个观察者合并成一个观察者,数据项根据时间戳来依次发送,也就是说,先添加的会被先发射

    final ArrayList<Integer> integers =new ArrayList<>();
    final ArrayList<String> strings =new ArrayList<>();
    for (int i = 0; i < 40; i++) {
        if (i%2==0) {
            integers.add(i);
        }else {
            strings.add("字符串"+i);
        }
    }
    Observable<ArrayList<String>> arrayListObservable = Observable.create(new ObservableOnSubscribe<ArrayList<String>>() {
        @Override
        public void subscribe(ObservableEmitter<ArrayList<String>> emitter) throws Exception {
            emitter.onNext(strings);
        }
    });
    Observable<ArrayList<Integer>> arrayListObservable1 = Observable.create(new ObservableOnSubscribe<ArrayList<Integer>>() {
        @Override
        public void subscribe(ObservableEmitter<ArrayList<Integer>> emitter) throws Exception {
            emitter.onNext(integers);
        }
    });
    Observable.merge(arrayListObservable1, arrayListObservable).subscribe(new Observer<ArrayList<? extends Serializable>>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onSubscribe: " );
        }

        @Override
        public void onNext(ArrayList<? extends Serializable> serializables) {
            for (Serializable serializable : serializables) {
                Log.e(TAG, "onNext: "+serializable );
            }
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onError: ");
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete: " );
        }
    });

    04-16 19:37:35.562 8355-8355/com.example.rxjavaandretrofit E/MainActivity: onNext: 32
    04-16 19:37:35.562 8355-8355/com.example.rxjavaandretrofit E/MainActivity: onNext: 34
    04-16 19:37:35.562 8355-8355/com.example.rxjavaandretrofit E/MainActivity: onNext: 36
    04-16 19:37:35.562 8355-8355/com.example.rxjavaandretrofit E/MainActivity: onNext: 38
    04-16 19:37:35.562 8355-8355/com.example.rxjavaandretrofit E/MainActivity: onNext: 字符串1
    04-16 19:37:35.562 8355-8355/com.example.rxjavaandretrofit E/MainActivity: onNext: 字符串3
    04-16 19:37:35.562 8355-8355/com.example.rxjavaandretrofit E/MainActivity: onNext: 字符串5

startWith 可以理解为将同类型的数据插入到最前方,例如在下文中将just1中的数据插入到了just的前面
`

Observable<Integer> just = Observable.just(2, 3423, 543, 534, 5, 23);
    Observable<Integer> just1 = Observable.just(1,42,23);
    just.startWith(just1).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "accept: "+integer );
        }
    });
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 1
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 42
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 23
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 2
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 3423
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 543
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 534
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 5
04-16 19:46:32.572 8419-8419/com.example.rxjavaandretrofit E/MainActivity: accept: 23
阅读更多
文章标签: RxJava Android
个人分类: android
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭