RxJava学习指南

基础用法

使用步骤：

初始化 Observable
初始化 Observer
订阅

当然不要忘了根据github地址添加依赖。

    private static Observable<Integer> getObservable() {
        return Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {

                Log.i(TAG, "subscribe:  发送 1 " + Thread.currentThread().getName());
                observableEmitter.onNext(1);

                Log.i(TAG, "subscribe:  发送 2 " + Thread.currentThread().getName());
                observableEmitter.onNext(2);

                Log.i(TAG, "subscribe:  发送 3 " + Thread.currentThread().getName());
                observableEmitter.onNext(3);

                Log.i(TAG, "subscribe:  发送 4 " + Thread.currentThread().getName());
                observableEmitter.onNext(4);
            }
        });
    }

    public static void step1() {
        // 1.初始化Obervable
        Observable<Integer> observable = getObservable();

        // 2.初始化Observer
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable disposable) {
                mDisposable = disposable;
            }

            @Override
            public void onNext(Integer integer) {
                Log.i(TAG, "onNext: 接收数据" + integer);

                if (integer == 3) {
                    Log.i(TAG, "onNext: 主动销毁数据" + integer);
                    mDisposable.dispose();
                }
            }

            @Override
            public void onError(Throwable throwable) {
                Log.i(TAG, "onError: 错误数据" + throwable.getMessage());
            }

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

        // 3.创建订阅关系
        observable.subscribe(observer);
    }

线程调度

subscribeOn：指定被订阅数据线程，即发送数据上游线程。多次调用仅第一次有效。

observeOn：指定观察者线程，即接收数据下游线程。多次调用多次生效，根据最近一次调用调度线程。

public static void scheduler() {
        Observable<Integer> observable = getObservable();
        observable
                .subscribeOn(AndroidSchedulers.mainThread()) // 主线程发射数据
                .subscribeOn(Schedulers.newThread()) // 子线程发射数据
                .subscribeOn(Schedulers.io()) // io线程发射数据
                .observeOn(AndroidSchedulers.mainThread()) // 主线程接收数据
                .doOnNext(new Consumer<Integer>() { // 在accept之前调用
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: AndroidSchedulers.mainThread() 当前线程" + Thread.currentThread().getName());
                        Log.i(TAG, "accept: AndroidSchedulers.mainThread() 接收数据" + integer);
                    }
                })
                .observeOn(Schedulers.io()) // io线程接收数据
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: AndroidSchedulers.io() 当前线程" + Thread.currentThread().getName());
                        Log.i(TAG, "accept: AndroidSchedulers.io() 接收数据" + integer);
                    }
                });
    }

doOnNext：在下游接收数据前调用。onNext()之前。

doAfterNext：在接收数据之后调用。onNext()之后。

关键字

create

产生一个 Obserable 被观察者对象，即上游发射器。

map

将发射出来的数据一一映射处理一遍。

public static void map() {
        Observable<Integer> observable = getObservable();
        // 将 int --> String
        observable.map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "map " + integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: ==" + s);
            }
        });
    }

flatMap/concatMap

将一组上游发射数据转换为N个Observable，之后无序/有序的发射这N个发射器的数据。

    public static void flatMap() {
        getIntObservable()
                .flatMap(new Function<Integer, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(Integer integer) throws Exception {
                        ArrayList<String> list = new ArrayList<>();
                        for (int i = 0; i < integer; i++) {
                            list.add("第" + integer + "波数据：" + i);
                        }
                        return Observable.fromIterable(list).delay(3-integer, TimeUnit.SECONDS);
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: 接收数据 " + s);
            }
        });
    }

timer

定时任务。订阅后延时多久开始发射数据。

    public static void timer() {
        final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        Log.i(TAG, "timer: 开始时间 " + dateFormat.format(System.currentTimeMillis()));
        Observable.timer(2,TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.i(TAG, "timer: 结束时间 " + dateFormat.format(System.currentTimeMillis()));
                    }
                });
    }

interval

计时任务。每隔一段时间发射一次数据。

延迟1s后开始计时，每次间隔1s，5s后标记任务为处理状态。

    public static void interval() {
        final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        Log.i(TAG, "timer: 开始时间 " + dateFormat.format(System.currentTimeMillis()));
        Disposable disposable = Observable.interval(1, 1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.i(TAG, "timer: 计时 " + dateFormat.format(System.currentTimeMillis()));
                    }
                });
        try {
            Thread.sleep(5000);
            disposable.dispose();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

zip

将两个或以上发射器数据合并在一起，按一一对应方式合并，所以最终结果是按照最小数量发射器，多的数据直接舍弃。从下例可以看出结果只能到 " three is 3" ，"four" 被舍弃了。

    public static void zip() {
        Observable.zip(getIntObservable(), getStringObservable(),
                new BiFunction<Integer, String, String>() {
                    @Override
                    public String apply(Integer integer, String s) throws Exception {
                        return s + " is " + integer;
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: " + s);
            }
        });
    }

private static Observable<Integer> getIntObservable() {
        return Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {

//                Log.i(TAG, "subscribe:  发送 1 " + Thread.currentThread().getName());
                observableEmitter.onNext(1);

//                Log.i(TAG, "subscribe:  发送 2 " + Thread.currentThread().getName());
                observableEmitter.onNext(2);

//                Log.i(TAG, "subscribe:  发送 3 " + Thread.currentThread().getName());
                observableEmitter.onNext(3);

                // 通知下游数据发送完成 后续数据不在接收
                observableEmitter.onComplete();

//                Log.i(TAG, "subscribe:  发送 4 " + Thread.currentThread().getName());
                observableEmitter.onNext(4);
            }
        });
    }

    private static Observable<String> getStringObservable() {
        return Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {

                observableEmitter.onNext("one");

                observableEmitter.onNext("two");

                observableEmitter.onNext("three");

                observableEmitter.onNext("four");

                // 通知下游数据发送完成 后续数据不在接收
                observableEmitter.onComplete();
            }
        });
    }

concat/merge

将两个上游发射器合并在一起，按照顺序依次发送数据/无序发送数据。合并的observable的数据类型必须相同。

    public static void concat(){
        Observable.concat(getIntObservable(),getIntObservable())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: " + integer);
                    }
                });
    }

从结果可以看concat出是在第一个observable之后有序发射第二个observable的数据。

distinct

去重，去除重复的数据。

class DistinctBean {

    String name;
    int id;

    public DistinctBean(String name, int id) {
        this.name = name;
        this.id = id;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof DistinctBean)) return false;
        DistinctBean that = (DistinctBean) o;
        return id == that.id &&
                Objects.equals(name, that.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

    private static Observable<DistinctBean> getDistinctObservable() {
        return Observable.create(new ObservableOnSubscribe<DistinctBean>() {
            @Override
            public void subscribe(ObservableEmitter<DistinctBean> observableEmitter) throws Exception {

                observableEmitter.onNext(new DistinctBean("a", 1));

                observableEmitter.onNext(new DistinctBean("b", 1));

                observableEmitter.onNext(new DistinctBean("b", 1));

                observableEmitter.onNext(new DistinctBean("b", 2));

                // 通知下游数据发送完成 后续数据不在接收
                observableEmitter.onComplete();
            }
        });
    }

1.不指定key，直接进行对象比较，过滤掉一个数据 {b,1}

        getDistinctObservable().distinct()
                .subscribe(new Consumer<DistinctBean>() {
                    @Override
                    public void accept(DistinctBean distinctBean) throws Exception {
                        Log.i(TAG, "accept:   " + distinctBean.toString());
                    }
                });

2.指定比较的key是name字段，过滤掉后两个数据

        getDistinctObservable().distinct(new Function<DistinctBean, String>() {
            @Override
            public String apply(DistinctBean distinctBean) throws Exception {
                return distinctBean.name;
            }
        }).subscribe(new Consumer<DistinctBean>() {
            @Override
            public void accept(DistinctBean distinctBean) throws Exception {
                Log.i(TAG, "accept:   " + distinctBean.toString());
            }
        });

filter

根据条件过滤掉无用数据。

    public static void filter(){
        getDistinctObservable().filter(new Predicate<DistinctBean>() {
            @Override
            public boolean test(DistinctBean distinctBean) throws Exception {
                // true 通过筛选
                return "b".equals(distinctBean.name);
            }
        }).subscribe(new Consumer<DistinctBean>() {
            @Override
            public void accept(DistinctBean distinctBean) throws Exception {
                Log.i(TAG, "accept: " + distinctBean.toString());
            }
        });
    }

buffer

分组截取，将上游发射器数据分组，新的发射器每次发射一组数据。

下例，每次游标滑动4，然后取后面的3个数为一个List发射。

结果为：[1,2,3] [5,6,7]

    public static void buffer() {
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
                .buffer(3, 4)
                .subscribe(new Consumer<List<Integer>>() {
                    @Override
                    public void accept(List<Integer> integers) throws Exception {
                        Log.i(TAG, "accept: " + integers.toString());
                    }
                });
    }

skip/skipLast

舍弃一些数据后开始接收数据。从前/从后

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

take/takeLast

只接收一定量的数据。从前/从后

    public static void take(){
        Observable.just(1,2,3,4,5,6)
                .take(2)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept:  " + integer); // 结果 1 2
                    }
                });
    }

single

单个数据发射器。SingleObserver只回调onSuccess和onError。

   public static void single(){
        Single.just(1)
                .subscribe(new SingleObserver<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

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

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

debounce/ThrottleWithTimeout

去抖动，覆盖掉间隔过短的数据，即有效数据为短间隔的后一个数据。

   public static void debounce() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1); // 被覆盖
                Thread.sleep(200);
                emitter.onNext(2); // 接收
                Thread.sleep(600);
                emitter.onNext(3); // 被覆盖
                Thread.sleep(300);
                emitter.onNext(4); // 被覆盖
                Thread.sleep(300);
                emitter.onNext(5); // 接收
            }
        }).throttleWithTimeout(400, TimeUnit.MILLISECONDS)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: " + integer); // 结果 2 5
                    }
                });
    }

last

只接收最后一个数据，当没有数据时，发射传入的默认值。

    public static void last() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onComplete();
            }
        }).last(3)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: " + integer); // 结果 3
                    }
                });
    }

reduce/scan

将数据按照方法依次两两操作，可以设置一个初始值。

reduce只关注结果的一次数据。

scan每一步的数据都发射一次。seed也会发射一次。

    public static void reduce(){
        Observable.just(1,2,3,4)
                .reduce(2, new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) throws Exception {
                        return integer + integer2;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.i(TAG, "accept: " + integer); // 结果 12   scan结果：2 3 5 8 12
            }
        });
    }

RxJava学习指南

基础用法

线程调度

关键字

create

map

flatMap/concatMap

timer

interval

zip

concat/merge

distinct

filter

buffer

skip/skipLast

take/takeLast

single

debounce/ThrottleWithTimeout

last

reduce/scan

python gdal 安装使用（Windows， python 3.6.8）

ListView展示不同類別

Fragment基礎

SVN update失敗 clean失敗

官方推薦的Dialog——DialogFragment

Button英文字母大寫問題

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結