（3）RxJava2+Retrofit2+OkHttp3系列（RxJava2-3）

这节我们还是聊一下Rxjava的操作符。

##操作符

###Concat

单一的把两个发射器连接成一个发射器。

Observable.concat(Observable.just(1,2,3), Observable.just(4,5,6))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer integer) throws Exception {
                        Log.e(TAG, "concat : "+ integer + "\n" );
                    }
                });

//结果
concat : 1
concat : 2
concat : 3
concat : 4
concat : 5
concat : 6

###distinct

去重操作

Observable.just(1, 1, 1, 2, 2, 3, 4, 5)
                .distinct()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer integer) throws Exception {
                        Log.e(TAG, "distinct : " + integer + "\n");
                    }
                });

//结果
distinct : 1
distinct : 2
distinct : 3
distinct : 4
distinct : 5

###Filter

过滤器——可以接受一个参数，让其过滤掉不符合我们条件的值。

Observable.just(1, 20, 65, -5, 7, 19)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(@NonNull Integer integer) throws Exception {
                        return integer >= 10;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer integer) throws Exception {
                Log.e(TAG, "filter : " + integer + "\n");
            }
        });

//结果
filter : 20
filter : 65
filter : 19

###buffer

buffer 操作符接受两个参数，buffer(count,skip)，作用是将 Observable 中的数据按 skip (步长) 分成最大不超过 count 的 buffer ，然后生成一个 Observable 。

Observable.just(1, 2, 3, 4, 5)
                .buffer(3, 2)
                .subscribe(new Consumer<List<Integer>>() {
                    @Override
                    public void accept(@NonNull List<Integer> integers) throws Exception {
                        Log.e(TAG, "buffer size : " + integers.size() + "\n");
                        for (Integer i : integers) {
                            Log.e(TAG, i + "");
                        }
                        Log.e(TAG, "\n");
                    }
                });

//结果
buffer size : 3
1
2
3
buffer size : 3
3
4
5
buffer size : 1
5

我们把 1, 2, 3, 4, 5 依次发射出来，经过 buffer 操作符，其中参数 skip 为 2， count 为 3，而我们的输出 依次是 123，345，5。显而易见，我们 buffer 的第一个参数是 count，代表最大取值，在事件足够的时候，一般都是取 count 个值，然后每次跳过 skip 个事件。

###Timer

timer相当于一个定时任务，在 1.x 中它还可以执行间隔逻辑，但在 2.x 中此功能被交给了 interval，但需要注意的是timer 和 interval 均默认在新线程。

Observable.timer(2, TimeUnit.SECONDS)
	.subscribeOn(Schedulers.io())
	.observeOn(AndroidSchedulers.mainThread()) // timer 默认在新线程，所以需要切换回主线程
	.subscribe(new Consumer<Long>() {
		@Override
		public void accept(@NonNull Long aLong) throws Exception {
			
		  }
});

###interval

interval 操作符用于间隔时间执行某个操作，其接受三个参数，分别是第一次发送延迟，间隔时间，时间单位。

	Observable.interval(3,2, TimeUnit.SECONDS)
		.subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread()) // 由于interval默认在新线程，所以我们应该切回主线程
        .subscribe(new Consumer<Long>() {
			@Override
			public void accept(@NonNull Long aLong) throws Exception {
                 }
	});

###doOnNext

其实doOnNext 应该不算一个操作符，但考虑到其常用性。它的作用是让订阅者在接收到数据之前干点有意思的事情。假如我们在获取到数据之前想先保存一下它，无疑我们可以这样实现。

Observable.just(1, 2, 3, 4)
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer integer) throws Exception {
                        Log.e(TAG, "doOnNext 保存 " + integer + "成功" + "\n");
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer integer) throws Exception {
                Log.e(TAG, "doOnNext :" + integer + "\n");
            }
        });

//结果
doOnNext 保存1成功
doOnNext :1
doOnNext 保存2成功
doOnNext :2
doOnNext 保存3成功
doOnNext :3
doOnNext 保存4成功
doOnNext :4

###skip

skip 接受一个 long 型参数 count ，代表跳过 count 个数目开始接收。

Observable.just(1,2,3,4,5)
                .skip(2)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer integer) throws Exception {
                        Log.e(TAG, "skip : "+integer + "\n");
                    }
                });

//结果
skip : 3
skip : 4
skip : 5

###take

take，接受一个 long 型参数 count ，代表至多接收 count 个数据。

Flowable.fromArray(1,2,3,4,5)
                .take(2)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer integer) throws Exception {
                        Log.e(TAG, "accept: take : "+integer + "\n" );
                    }
                });

//结果
accept: take : 1
accept: take : 2

###just

一个简单的发射器依次调用 onNext() 方法。

Observable.just("1", "2", "3")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.e(TAG,"onNext : " + s + "\n" );
                    }
                });

//结果
onNext : 1
onNext : 2
onNext : 3

本节就说到这里了，下节我们将剩下的操作符继续说完！！！