RxJava从入门到精通

1.简介

RxJava是一套异步编程的API，是基于观察者模式的，而且是链式调用

RxJava三个基本要素：

(1) 被观察者(Observable)

(2) 观察者(Observer)

(3) 订阅(subcribe)

首先在gradle文件中添加依赖：

implementation 'io.reactivex.rxjava2:rxjava:2.1.4'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

        //1.创建被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.i("zhoujian", "currentThread name=" + Thread.currentThread().getName());
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        });

        //2.创建观察者
        Observer observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log.i("zhoujian", "onNext=" + integer);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        };

        //3.订阅：被观察者订阅观察者
        observable.subscribe(observer);

打印结果：

06-15 11:24:19.331 11911-11911/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-15 11:24:19.332 11911-11911/com.zhoujian.rxjavademo I/zhoujian: currentThread name=main
06-15 11:24:19.332 11911-11911/com.zhoujian.rxjavademo I/zhoujian: onNext=1
06-15 11:24:19.332 11911-11911/com.zhoujian.rxjavademo I/zhoujian: onNext=2
06-15 11:24:19.332 11911-11911/com.zhoujian.rxjavademo I/zhoujian: onNext=3
06-15 11:24:19.332 11911-11911/com.zhoujian.rxjavademo I/zhoujian: onComplete

链式调用

        //使用链式调用
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.i("zhoujian", "currentThread name=" + Thread.currentThread().getName());
                e.onNext(4);
                e.onNext(5);
                e.onNext(6);
                e.onComplete();

            }
        }).subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log.i("zhoujian", "onNext=" + integer);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });
        

打印结果：

06-15 11:29:34.376 12082-12082/? I/zhoujian: onSubscribe
06-15 11:29:34.376 12082-12082/? I/zhoujian: currentThread name=main
06-15 11:29:34.376 12082-12082/? I/zhoujian: onNext=4
06-15 11:29:34.377 12082-12082/? I/zhoujian: onNext=5
06-15 11:29:34.377 12082-12082/? I/zhoujian: onNext=6
06-15 11:29:34.377 12082-12082/? I/zhoujian: onComplete

被观察者发送的事件有以下几种

事件种类	作用
onNext()	发送该事件时，观察者会回调 onNext() 方法
onError()	发送该事件时，观察者会回调 onError() 方法，当发送该事件之后，其他事件将不会继续发送
onComplete()	发送该事件时，观察者会回调 onComplete() 方法，当发送该事件之后，其他事件将不会继续发送

2.各种操作符

(1) create() :创建一个被观察者

 
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("你好！观察者");
                emitter.onComplete();
            }
        });

(2) just() : 创建一个被观察者，并发送事件，发送事件不能超过10个

Observable.just(1,2,3).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log.i("zhoujian", "onNext="+integer);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-15 13:30:04.761 14162-14162/? I/zhoujian: onSubscribe
06-15 13:30:04.761 14162-14162/? I/zhoujian: onNext=1
06-15 13:30:04.761 14162-14162/? I/zhoujian: onNext=2
06-15 13:30:04.761 14162-14162/? I/zhoujian: onNext=3
06-15 13:30:04.761 14162-14162/? I/zhoujian: onComplete

(3) fromArray()

和just()方法类似，用于创建一个被观察者，fromArray可以传入多余10个的变量，并且可以传入一个

Integer[] array = {4, 5, 6};
        Observable.fromArray(array).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log.i("zhoujian", "onNext="+integer);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-15 14:16:12.734 16231-16231/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-15 14:16:12.735 16231-16231/com.zhoujian.rxjavademo I/zhoujian: onNext=4
06-15 14:16:12.735 16231-16231/com.zhoujian.rxjavademo I/zhoujian: onNext=5
06-15 14:16:12.735 16231-16231/com.zhoujian.rxjavademo I/zhoujian: onNext=6
06-15 14:16:12.735 16231-16231/com.zhoujian.rxjavademo I/zhoujian: onComplete

(4) fromCallable()

Callable和Runnable用法基本一致，只是它返回一个结果值，这个结果值就是发送给观察者的

 Observable.fromCallable(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 6;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.i("zhoujian", "accept="+integer);
            }
        });

返回结果：

06-15 14:37:13.855 18327-18327/? I/zhoujian: accept=6

(5) fromFuture()

Future的作用增加了cancel()等方法操作Callable，它可以通过get()方法来获取Callable返回的值

        final FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "Sucessed";
            }
        });

        Observable.fromFuture(futureTask).doOnSubscribe(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                futureTask.run();
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i("zhoujian", "accept="+s);
            }
        });

        
        

返回结果：

06-15 14:57:28.904 19576-19576/com.zhoujian.rxjavademo I/zhoujian: accept=Sucessed

(6) fromIterrable

直接发送一个List集合给观察者

 List<String> list = new ArrayList<>();
        list.add("7");
        list.add("8");
        list.add("9");
        list.add("10");
        Observable.fromIterable(list).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(String s) {
                Log.i("zhoujian", "onNext="+s);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-15 15:09:01.927 20242-20242/? I/zhoujian: onSubscribe
06-15 15:09:01.927 20242-20242/? I/zhoujian: onNext=7
06-15 15:09:01.927 20242-20242/? I/zhoujian: onNext=8
06-15 15:09:01.927 20242-20242/? I/zhoujian: onNext=9
06-15 15:09:01.927 20242-20242/? I/zhoujian: onNext=10
06-15 15:09:01.927 20242-20242/? I/zhoujian: onComplete

(7) defer（）

这个方法作用是直到被观察者被订阅后才会创建被观察者

private Integer integer = 1;

        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> call() throws Exception {
                return Observable.just(integer);
            }
        });
        integer = 2;
        Observer observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log.i("zhoujian", "onNext="+integer);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        };
        //被观察者订阅观察者
        observable.subscribe(observer);
        integer = 3;
        observable.subscribe(observer);
        
        

打印结果：

06-15 15:35:50.567 21116-21116/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-15 15:35:50.568 21116-21116/com.zhoujian.rxjavademo I/zhoujian: onNext=2
06-15 15:35:50.568 21116-21116/com.zhoujian.rxjavademo I/zhoujian: onComplete
06-15 15:35:50.568 21116-21116/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-15 15:35:50.568 21116-21116/com.zhoujian.rxjavademo I/zhoujian: onNext=3
06-15 15:35:50.568 21116-21116/com.zhoujian.rxjavademo I/zhoujian: onComplete

(8) timer（）

当到指定时间后，发一个Long型的值0L 给观察者

10秒之后，发一个Long型的0L 给观察者

 Observable.timer(10, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Long aLong) {
                Log.i("zhoujian", "onNext="+aLong);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-20 08:55:24.449 1505-1505/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-20 08:55:34.451 1505-1573/com.zhoujian.rxjavademo I/zhoujian: onNext=0
06-20 08:55:34.452 1505-1573/com.zhoujian.rxjavademo I/zhoujian: onComplete

(9) interval（）

每隔一段时间会发送一个事件，这个事件从0开始，不断增加1

每隔5秒发送一个事件

  Observable.interval(5,TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Long aLong) {
                Log.i("zhoujian", "onNext="+aLong);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-20 09:10:57.196 3826-3826/? I/zhoujian: onSubscribe
06-20 09:11:02.199 3826-3887/com.zhoujian.rxjavademo I/zhoujian: onNext=0
06-20 09:11:07.198 3826-3887/com.zhoujian.rxjavademo I/zhoujian: onNext=1
06-20 09:11:12.198 3826-3887/com.zhoujian.rxjavademo I/zhoujian: onNext=2
06-20 09:11:17.198 3826-3887/com.zhoujian.rxjavademo I/zhoujian: onNext=3
06-20 09:11:22.198 3826-3887/com.zhoujian.rxjavademo I/zhoujian: onNext=4
06-20 09:11:27.198 3826-3887/com.zhoujian.rxjavademo I/zhoujian: onNext=5
06-20 09:11:32.198 3826-3887/com.zhoujian.rxjavademo I/zhoujian: onNext=6

(10) intervalRange()

可以指定发送事件的开始值和数量，其他功能与interval（）功能一样

 //从3开始，发送4次事件，间隔2秒，延时1秒
        Observable.intervalRange(3,4,1,2,TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Long aLong) {
                Log.i("zhoujian", "onNext="+aLong);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });
        
        

打印结果：

06-25 13:31:15.130 9797-9797/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-25 13:31:16.131 9797-10125/com.zhoujian.rxjavademo I/zhoujian: onNext=3
06-25 13:31:18.131 9797-10125/com.zhoujian.rxjavademo I/zhoujian: onNext=4
06-25 13:31:20.131 9797-10125/com.zhoujian.rxjavademo I/zhoujian: onNext=5
06-25 13:31:22.131 9797-10125/com.zhoujian.rxjavademo I/zhoujian: onNext=6
06-25 13:31:22.131 9797-10125/com.zhoujian.rxjavademo I/zhoujian: onComplete

(11) range()

同时发送一定范围的事件序列

 //从3开始，发送5个事件
        Observable.range(3,5).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log.i("zhoujian", "onNext="+integer);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-25 13:43:13.234 11673-11673/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-25 13:43:13.234 11673-11673/com.zhoujian.rxjavademo I/zhoujian: onNext=3
06-25 13:43:13.234 11673-11673/com.zhoujian.rxjavademo I/zhoujian: onNext=4
06-25 13:43:13.234 11673-11673/com.zhoujian.rxjavademo I/zhoujian: onNext=5
06-25 13:43:13.234 11673-11673/com.zhoujian.rxjavademo I/zhoujian: onNext=6
06-25 13:43:13.234 11673-11673/com.zhoujian.rxjavademo I/zhoujian: onNext=7
06-25 13:43:13.234 11673-11673/com.zhoujian.rxjavademo I/zhoujian: onComplete

(12) map（）

map 可以将被观察者发送的数据类型转变成其他类型

        //将Integer类型的数据转成String类型
        Observable.just(1, 2, 3).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "我是字符串："+integer;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(String s) {
                Log.i("zhoujian", "onNext="+s);
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-25 13:58:45.536 12272-12272/? I/zhoujian: onSubscribe
06-25 13:58:45.536 12272-12272/? I/zhoujian: onNext=我是字符串：1
06-25 13:58:45.536 12272-12272/? I/zhoujian: onNext=我是字符串：2
06-25 13:58:45.536 12272-12272/? I/zhoujian: onNext=我是字符串：3
06-25 13:58:45.536 12272-12272/? I/zhoujian: onComplete

(13) flatMap（）

与map() 类似  flatMap() 返回一个新的被观察者

将多个电影转换成多个演员输出

先准备数据

Actor.java

package com.zhoujian.rxjavademo;

/**
 * Created by zhoujian on 2018/6/25.
 */

public class Actor {

    private String name;
    private String  sex;

    public Actor(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

Movie.java

package com.zhoujian.rxjavademo;

import java.util.List;

/**
 * Created by zhoujian on 2018/6/25.
 */

public class Movie
{

    private String name;
    private int id;
    private String data;
    private List<Actor> mactorList;

    public Movie(String data, int id, List<Actor> mactorList, String name)
    {
        this.data = data;
        this.id = id;
        this.mactorList = mactorList;
        this.name = name;
    }


    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public List<Actor> getMactorList() {
        return mactorList;
    }

    public void setMactorList(List<Actor> mactorList) {
        this.mactorList = mactorList;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "Movie{" +  "data='" + data + '\'' + ", name='" + name + '\'' +", id=" + id + ", mactorList=" + mactorList + '}';
    }
}

 private void getDatas() {
        Actor actor1 = new Actor("周星驰", "男");
        Actor actor2 = new Actor("张柏芝", "女");
        ArrayList<Actor> movie1List = new ArrayList<Actor>();
        movie1List.add(actor1);
        movie1List.add(actor2);
        Movie movie1 = new Movie("1998-10-14", 1, movie1List, "喜剧之王");
        moveList.add(movie1);
        Actor actor3 = new Actor("罗志祥", "男");
        Actor actor4 = new Actor("张雨绮", "女");
        ArrayList<Actor> movie2List = new ArrayList<Actor>();
        movie2List.add(actor3);
        movie2List.add(actor4);
        Movie movie2 = new Movie("2016-05-01", 2, movie2List, "美人鱼");
        moveList.add(movie2);
    }

 //将多个电影转换成多个演员输出
        Observable.fromIterable(moveList).flatMap(new Function<Movie, ObservableSource<Actor>>() {
            @Override
            public ObservableSource<Actor> apply(Movie movie) throws Exception {
                return Observable.fromIterable(movie.getMactorList());
            }
        }).subscribe(new Observer<Actor>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(Actor actor) {
                Log.i("zhoujian", "onNext="+actor.toString());
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });

打印结果：

06-25 15:22:38.233 15514-15514/? I/zhoujian: onSubscribe
06-25 15:22:38.233 15514-15514/? I/zhoujian: onNext=Actor{name='周星驰', sex='男'}
06-25 15:22:38.233 15514-15514/? I/zhoujian: onNext=Actor{name='张柏芝', sex='女'}
06-25 15:22:38.233 15514-15514/? I/zhoujian: onNext=Actor{name='罗志祥', sex='男'}
06-25 15:22:38.233 15514-15514/? I/zhoujian: onNext=Actor{name='张雨绮', sex='女'}
06-25 15:22:38.234 15514-15514/? I/zhoujian: onComplete

(14) concatMap（）

concatMap()和flatMap() 基本是一样的，只不过concatMap发出去的事件是有序的，而flatMap是无序的

(15) buffer()

从需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区当中一并发出

buffer 有2个参数，一个是count ，另一个是skip。 count 缓冲区元素的数量，skip 代表缓冲区满后，发送下一次事件序列的时候要跳过多少元素

 Observable.just(1,2,3,4,5).buffer(3,1).subscribe(new Observer<List<Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("zhoujian", "onSubscribe");
            }

            @Override
            public void onNext(List<Integer> integers) {
                Log.i("zhoujian", "缓冲区大小-----------："+integers.size());
                for (Integer i: integers){
                    Log.i("zhoujian", "缓冲区元素："+i);
                }
            }

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

            @Override
            public void onComplete() {
                Log.i("zhoujian", "onComplete");
            }
        });
        

打印结果：

06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: onSubscribe
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区大小-----------：3
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：1
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：2
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：3
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区大小-----------：3
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：2
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：3
06-25 16:15:23.796 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：4
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区大小-----------：3
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：3
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：4
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：5
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区大小-----------：2
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：4
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：5
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区大小-----------：1
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: 缓冲区元素：5
06-25 16:15:23.797 18271-18271/com.zhoujian.rxjavademo I/zhoujian: onComplete

RxJava上篇

RxJava中篇

RxJava下篇