【Android】Rxjava操作符系列（一）

今天开始Rxjava的学习，废话不多说了，开始撸操作符了

1.Create

作用：通过调用观察者的方法从头创建一个Observable.

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onNext(3);
                subscriber.onNext(4);
                subscriber.onCompleted();
            }
        });

        Subscription subscription = observable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("rxjava","value = "+integer.toString());
            }
        });

结果：

2.defer

作用：只有当订阅者订阅才创建Observable，为每个订阅创建一个新的Observable.

        int i = 12;
        Observable deferObservable = Observable.defer(new Func0<Observable<Integer>>() {
            @Override
            public Observable<Integer> call() {
                return Observable.just(i);
            }
        });
        i = 15;
        Subscription defersub = deferObservable.subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {
                Log.e("rxjava","defer value = "+o.toString());
            }
        });

结果：

3.from

作用：from操作符可以转换Future、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据.

Observable<Integer> observable = Observable.from(new Integer[]{1, 2, 3, 4, 5});
        Subscription sub = observable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("rxjava","from value = "+integer.toString());
            }
        });

结果：

4.just

作用：Just类似于From，但是From会将数组或Iterable的数据取出然后逐个发射，而Just只是简单的原样发射，将数组或Iterable当做单个数据.

Subscription sub = Observable.just(1, 2, 3, 4, 5)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("rxjava","just value = "+integer.toString());
                    }
                });

结果：

5.range

作用：Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度.

Subscription sub = Observable.range(3, 5)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("rxjava","range value = "+integer.toString());
                    }
                });

结果：

6.repeat

作用：Repeat重复地发射数据。某些实现允许你重复的发射某个数据序列，还有一些允许你限制重复的次数.

Subscription sub = Observable.range(3, 5)
                .repeat(2)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("rxjava","repeat value = "+integer.toString());
                    }
                });

结果：

7.timer

作用：timer创建一个Observable，它在一个给定的延迟后发射一个特殊的值0.

Subscription sub = Observable.timer(2, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long value) {
                        Log.e("rxjava","timer value = "+value.toString());
                    }
                });

结果：

8.interval

作用：创建一个按固定时间间隔发射整数序列的Observable,例子中没2秒输出一次，value大于5停止输出.

Observable.interval(2, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long value) {
                        if (value > 5) {
                            sub.unsubscribe();
                            return;
                        }
                        Log.e("rxjava","interval value = "+value.toString());
                    }
                });

结果：

9.buffer

作用：将源Observable变换一个新的Observable，这个新的Observable每次发射一组列表值而不是一个一个发射.

1.buffer(a,b)

Subscription sub = Observable.range(1,5).buffer(5,1)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<Integer>>() {
                    @Override
                    public void call(List<Integer> integers) {
                        Log.e("rxjava","interval value = "+integers.toString());
                    }
                });

结果：

2.buffer(a)

Subscription sub = Observable.range(1,5).buffer(2)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<Integer>>() {
                    @Override
                    public void call(List<Integer> integers) {
                        Log.e("rxjava","buffer value = "+integers.toString());
                    }
                });

结果：

10.flatmap

作用：flatmap把一个Observable变成多个Observable，然后把得到的多个Obervable的元素一个个的发射出去,下面的例子是把输入三个teacher对象，最后以此输出每个teacher的name的hashcode值.

Subscription sub = Observable.just(new Teacher("张三",18),new Teacher("李四",23),new Teacher("王五",21))
                .flatMap(new Func1<Teacher, Observable<String>>() {
                    @Override
                    public Observable<String> call(Teacher teacher) {
                        return Observable.just(teacher.getName().hashCode()+"");
                    }
                })
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.e("rxjava","flatmap value = "+s);
                    }
                });

结果：

11.groupby

作用：对数据按照一定个规则进行分组

Subscription sub =  Observable.range(1, 10).groupBy(new Func1<Integer, String>() {
            @Override
            public String call(Integer integer) {
                return (integer % 2 == 0) ? "偶数组" : "奇数组";
            }
        }).subscribe(new Action1<GroupedObservable<String, Integer>>() {
            @Override
            public void call(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) {
                    stringIntegerGroupedObservable.subscribe(new Action1<Integer>() {
                        @Override
                        public void call(Integer integer) { 
                            Log.e("rxjava","groupby key = "+stringIntegerGroupedObservable.getKey()+" value = "+integer.toString());
                        }
                    });
            }
        });

结果：

12.map

作用：Map操作符对原始Observable发射的每一项数据应用一个函数，然后返回一个发射这些结果的Observable，例子：打印老师列表对象的名字：

Subscription sub = Observable.just(new Teacher("张三",18),new Teacher("李四",23),new Teacher("王五",21))
                //使用map进行转换，参数1：转换前的类型，参数2：转换后的类型
                .map(new Func1<Teacher, String>() {
                    @Override
                    public String call(Teacher i) {
                        String name = i.getName();//获取Student对象中的name
                        return name;//返回name
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.e("rxjava","map value = "+s);
                    }
                });

结果：

map和flatmap的区别：map，是把发射对象转成另外一个对象发射出去，flatMap, 是把发射对象转成另外一个Observable,进而把这个Observable发射的对象发射出去；

13.scan

作用：sacn操作符是遍历源Observable产生的结果，再按照自定义规则进行运算，依次输出每次计算后的结果给订阅者，call 回掉第一个参数是上次的结算结果，第二个参数是当此的源observable的输入值。例子：1到5依次进行scan计算：

 Subscription sub = Observable.range(1,5)
                .scan(new Func2<Integer, Integer, Integer>() {
                    @Override
                    public Integer call(Integer sum, Integer inv) {
                        return sum+inv;
                        //计算顺序：sum一开始为0，0+1 输出1，此时sum为1，1+2 输出3，此时sum为3 3+3 输出6，以此类推
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer s) {
                        Log.e("rxjava","map value = "+s);
                    }
                });

结果：

14.window

作用：window发射的是Observable而不是列表。下面展示了window()如何缓存3个数据项并把它们作为一个新的Observable发射出去.

Observable.range(1, 10).window(3).subscribe(new Action1<Observable<Integer>>() {
            @Override
            public void call(final Observable<Integer> obser) {
                obser.subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("rxjava","window obser = "+obser+"  value = "+integer.toString());
                    }
                });
            }
        });

结果：

欲知后事如何，请看下回分解！