Rxjava1和Rxjava2的区别

出现了两种观察者模式：
Observable ( 被观察者 ) / Observer ( 观察者 )
Flowable （被观察者）/ Subscriber （观察者）

可以使用下面的代码进行打算执行

if(!disposable.isDisposed()){
    disposable.dispose();
}

使用Consumer来代替Action等方法 表示有多少个返回值
Consumer 即消费者，用于接收单个值，BiConsumer 则是接收两个值，Function 用于变换对象，Predicate 用于判断
Func1 和 Func2 改为了 Function 和 BiFunction。表示有多少个参数。

可以使用doOnNext() 来处理数据变化后的工作，并且可以指定线程。
每次调用observeOn()就能切换一次线程

map 操作符 和rxjava1相同
采用 concat 操作符先读取缓存再通过网络请求获取数据 例如:很多时候（对数据操作不敏感时）都需要我们先读取缓存的数据，如果缓存没有数据，再通过网络请求获取，随后在主线程更新我们的UI。利用 concat 的必须调用 onComplete 后才能订阅下一个 Observable 的特性，我们就可以先读取缓存数据，倘若获取到的缓存数据不是我们想要的，再调用 onComplete() 以执行获取网络数据的 Observable，如果缓存数据能应我们所需，则直接调用 onNext()，防止过度的网络请求，浪费用户的流量。
concat连接操作符，依次执行两个Observable对象。

Observable.concat(cacheObservable, netWorkObservable).xxx  这里面的两个参数就是Observable对象

zip 操作符。 该合并不是连接。 zip 操作符可以将多个 Observable 的数据结合为一个数据源再发射出去。 zip 组合事件的过程就是分别从发射器 A 和发射器 B 各取出一个事件来组合，并且一个事件只能被使用一次，组合的顺序是严格按照事件发送的顺序来进行的。

Observable.zip(firstObservable, integerObservable, new BiFunction<String, Integer, String>() {
        @Override
        public String apply(String s, Integer integer) throws Exception {
            return s + integer + "==啦啦";
        }
}).

使用Map 和flatMap的区别就是Map返回的具体的对象，而flatMap返回的是Observable对象。
在concatMap和flatMap的区别就是concatMap保证了执行的顺序性，并且如果在concatMap中做延时后，能够保证每个onNext()执行都被延时。但是flatMap()就会在一次延时后全部执行。

Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
    emitter.onNext(1);
    emitter.onNext(2);
    emitter.onNext(3);
}
}).concatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(Integer integer) throws Exception {

        ArrayList<String> strings = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            strings.add(i + "");
        }
    return Observable.fromIterable(strings).delay(2, TimeUnit.SECONDS);
}
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
    Log.e("TAG", "s===" + s);
}
});

distinct() 进行数组的去重

Observable.just(1, 1, 1, 1, 2, 2, 2, 2)
.distinct().subscribe(new Consumer<Integer>() {
   @Override
    public void accept(Integer integer) throws Exception {
	    Log.e("TAG", "integer===" + integer);
  }
});

filter() 进行过滤，设置过滤条件

Observable.just(1, 323, 434, 66, 88, 9999)
.filter(new Predicate<Integer>() {
    @Override
    public boolean test(Integer integer) throws Exception {
        return integer < 100;
    }
}).subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.e("TAG", "integer==" + integer);
    }
});

buffer(count ,skip) 这是将Observable中的数据按照skip分成不超过count的buffer

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 {
        StringBuilder mRxOperatorsText=new StringBuilder();
        for (Integer i : integers) {
            mRxOperatorsText.append(i + "");
            Log.e("TAG", i + "");
        }
        mRxOperatorsText.append("\n");
        Log.e("TAG", "\n");
    }
});

这是先将1，2，3分成一组，然后跳过2个后，将3,4,5分成一组，然后又跳过2个，将5分成一组。然后打印

Timer()相当于一个定时任务

Observable.timer(2, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) throws Exception {
            Log.e("TAG", "along==" + aLong);
        }
});

interval(延迟时间，间隔时间，时间单位) 操作符实现心跳间隔任务，这个是循环的定时器

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

这个要注意防止内存的泄漏，应该在onDestroy()中判断

if(mDisposable!=null&&!mDisposable.isDisposed){
mDisposable.dispose();
}

doOnNext() 这是在订阅者最终获取数据的时候，做一些的数据处理，比如做一些数据的存储。

skip(count) 表示跳过count个数组开始接受数据。

take(count）表示最多获取count条数据

just(A ,B,C…) 表示依次发射事件。

Single 只会接受一个参数

Single.just(1)
.subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.e("TAG", "integer==" + integer);
    }
});

debounce（时间，单位） 去除抖动 去除频率过高的数据 也就是去除小于这个时间的数据

last()获取到最后一条数据

merge就是将多个Observable结合起来，但是和concat的区别就是不用等到第一个Observable发送完毕再进行下一个Observable的发送。
reduce() 可以对just()中的数值进行统一的计算，显示最终的结果

Observable.just(1, 2, 3)
.reduce(new BiFunction<Integer, Integer, Integer>() {
    @Override
    public Integer apply(Integer integer, Integer integer2) throws Exception {
        Log.e("TAG", "integer==" + integer + " integer2==" + integer2);
        return integer + integer2;
    }
}).subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
         Log.e("TAG", "integer==" + integer);
    }
});

scan() 和上面的reduce()功能相同，但是会把每一步的都结果都显示出来。

https://github.com/amitshekhariitbhu/Fast-Android-Networking 支持rxjava的okhttp库 Fast-Android-Networking