Android Rxjava操作符使用详情（一）

一、简单介绍：

函数响应式编程可以极大简化项目，特别是处理嵌套回调、复杂的列表过滤和变换或者时间相关问题。Rxjava就是在android开发中使用函数响应式编程的框架。

二、Rxjava原理：

创建一个Observable对象来干活，然后使用各种操作符建立起来的链式操作，就如同流水线一样，把你想要处理的数据一步一步地加工成你想要的成品，然后发射给Subscriber处理。

三、Rxjava与观察者模式：

Observable与Observer通过subscribe方法实现订阅关系，Observable就可以在需要的时候通知Observer。observable.subscribe(subcriner);被观察者—>订阅观察者。

四、Rxjava操作符

1、创建操作符
1）interval 创建一个按固定时间间隔发射整数序列的Observable（相当于定时器）

    public void interval() {
        Observable.interval(3, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                System.out.println("ds>>> interval=" + aLong.intValue());
            }
        });
    }

2）range 发射一个范围内的有序整数序列，可以拿来替换for循环，第一个参数不小于0，左闭右开。

 public void range() {
        Observable.range(0, 5).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> range=" + integer.intValue());
            }
        });
    }

3）repeat 创建一个N次重复发射特定数据的Observable。

    public void repeat() {
        Observable.range(0, 3).repeat(2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> repeat=" + integer.intValue());
            }
        });
    }

2、变换操作符
1）map 通过指定一个Func对象，将Observale转换为一个新的Observable对象发射，观察者将收到新的Observable处理。

 public void map() {
        final String host = "http://blog.csdn.net/";
        Observable.just("it").map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return host + s;
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println("ds>>> map=" + s);
            }
        });
    }

2）flatMap 将Observable发射的数据集合变换为Obserable集合，然后将这些Obserable发射的数据平坦化地放进一个单独的Obserable。case 是强制将Obserable发射的所有数据转换为指定类型。

    public void flatmap_cast() {
        final String host = "http://blog.net/";
        List<String> list = new ArrayList<>();
        list.add("hehe1");
        list.add("hehe2");
        list.add("hehe3");
        Observable.from(list).flatMap(new Func1<String, Observable<?>>() {
            @Override
            public Observable<?> call(String s) {
                return Observable.just(host + s);
            }
        }).cast(String.class).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println("ds>>> flatmap_cast=" + s);
            }
        });
    }

3）flatMapIterable 将数据包装成Iterable

  public void flatMapIterable() {
        Observable.just(1, 2, 3).flatMapIterable(new Func1<Integer, Iterable<Integer>>() {
            @Override
            public Iterable<Integer> call(Integer integer) {
                List<Integer> list = new ArrayList<Integer>();
                list.add(integer + 1);
                return list;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> flatmap_cast=" + integer);
            }
        });
      }

4)buffer 缓存

   public void buffer() {
        Observable.just(1, 2, 3, 4, 5, 6).buffer(3).subscribe(new Action1<List<Integer>>() {
            @Override
            public void call(List<Integer> integers) {
                for (Integer i : integers) {
                    System.out.println("ds>>> buffer=" + i);
                }
                System.out.println("ds>>> ---------------");
            }
        });
    }

5)groupBy 用于分组元素

    class Person {
        String name;
        String score;

        public Person(String name, String score) {
            this.name = name;
            this.score = score;
        }

        public String getScore() {
            return score;
        }

        public String getName() {
            return name;
        }
    }

    public void groupBy() {
        Person p1 = new Person("张三", "S");
        Person p2 = new Person("李四", "D");
        Person p3 = new Person("王五", "C");
        Person p4 = new Person("宋青", "A");
        Person p5 = new Person("周端", "B");
        Observable<GroupedObservable<String, Person>> g = Observable.just(p1, p2, p3, p4, p5).groupBy(new Func1<Person, String>() {
            @Override
            public String call(Person person) {
                return person.getScore();
            }
        });
        Observable.concat(g).subscribe(new Action1<Person>() {
            @Override
            public void call(Person person) {
                System.out.println("ds>>> groupBy=" + person.getName() + "----" + person.getScore());
            }
        });
    }

3、过滤操作符
1）filter 对源Observable产生的结果自定义规则进行过滤

    public void filter() {
        Observable.just(1, 2, 3, 4).filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer > 2;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> filter=" + integer);
            }
        });
    }

2)elementAt 用来返回指定位置的数据

 public void elementAt(){
        Observable.just(1,2,3,4).elementAt(2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> elementAt=" + integer);
            }
        });
    }

3)distinct 去重

  public void distinct(){
        Observable.just(1,2,3,3,2,5).distinct().subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> distinct=" + integer);
            }
        });
    }

4)skip、take 前者会过滤掉前n项，后者只取前n项。

 public void skip(){
        Observable.just(1,2,3,4,5,6).skip(2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> skip=" + integer);
            }
        });
    }
    public void take(){
        Observable.just(1,2,3,4,5,6).take(2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> skip=" + integer);
            }
        });
    }

5)ignoreElement 忽略源Observable产生的结果，只把Observable的onCompleted和onError事件通知给订阅者。

    public void ignoreElement(){
    Observable.just(1,2,3,4,5).ignoreElements().subscribe(new Observer<Integer>() {
        @Override
        public void onCompleted() {
            System.out.println("ds>>> ignoreElement 打印onCompleted");
        }

        @Override
        public void onError(Throwable e) {
            System.out.println("ds>>> ignoreElement 打印onError");
        }

        @Override
        public void onNext(Integer integer) {
            System.out.println("ds>>> ignoreElement 不打印onNext");
        }
    });
}

6)throttleFirst 定期发送这个时间段里源Observable发射的第一个数据。
    public void throttleFirst() {
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 10; i++) {
                    subscriber.onNext(i);
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                subscriber.onCompleted();
            }
        }).throttleFirst(200, TimeUnit.MILLISECONDS).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>> throttleFirst integer=" + integer);
            }
        });
    }

4、组合操作符
1）startWith 会在源Observable发射的数据前面插上一些数据。

 public void startWith(){
        Observable.just(3,4,5).startWith(1,2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>>startWith integer=" + integer);
            }
        });
    }

2)merge 将多个Observable合并到一个Observable中进行发射，merge可能让合并的Observable发射的数据交错。

  public void merge() {
        Observable<Integer> o1 = Observable.just(1, 2, 3).subscribeOn(Schedulers.io());
        Observable<Integer> o2 = Observable.just(3, 4, 5);
        Observable.merge(o1, o2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>>merge integer=" + integer);
            }
        });
    }

3)concat 将多个Observable发射的数据进行合并发射。contact严格按照顺序发射数据，前一个Observable没发射完是不会发射后一个Observable的数据的。

 public void contact() {
        Observable<Integer> o1 = Observable.just(1, 2, 3).subscribeOn(Schedulers.io());
        Observable<Integer> o2 = Observable.just(3, 4, 5);
        Observable.concat(o1, o2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("ds>>>contact integer=" + integer);
            }
        });
    }

4)zip 合并两个或者多个Observables发射出的数据项，根据指定的函数Func变换它们，并发射一个新值。

    public void zip() {
        Observable<Integer> o1 = Observable.just(1, 2, 3);
        Observable<String> o2 = Observable.just("aa", "bb", "cc");
        Observable.zip(o1, o2, new Func2<Integer, String, String>() {
            @Override
            public String call(Integer integer, String s) {
                return integer + s;
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println("ds>>>zip =" + s);
            }
        });
    }