RxJava之常用操作符整理

关于RxJava的概念就不阐述了，这里列举一些常用的操作符和创建方式

前提

本文所说的操作符和创建方式是基于RxJava2的版本，因为RxJava1中可能不支持其中的一些方法。具体build.gradle

    compile 'io.reactivex.rxjava2:rxjava:2.1.1'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

创建方式

• just()方式
  使用just( )，将为你创建一个Observable并自动为你调用onNext( )发射数据。通过just( )方式 直接触发onNext()，just中传递的参数将直接在Observer的onNext()方法中接收到。

Observable<String> observable = Observable.just("Hello");

• fromIterable()方式/from()方式
  使用fromIterable()，遍历集合，发送每个item。相当于多次回调onNext()方法，每次传入一个item。
  注意：Collection接口是Iterable接口的子接口，所以所有Collection接口的实现类都可以作为Iterable对象直接传入fromIterable()方法。如果想要简单点传参数就使用from();

List<String> list = new ArrayList<String>();
        for(int i =0;i<10;i++){
            list.add("Hello"+i);
        }
//fromIterable()方式
Observable<String> observable = Observable.fromIterable((Iterable<String>) list);
//from()方式
Observable<String> observable = Observable.from(list);

• defer()方式
  当观察者订阅时，才创建Observable，并且针对每个观察者创建都是一个新的Observable。以何种方式创建这个Observable对象，当满足回调条件后，就会进行相应的回调。

Observable<String> observable = Observable.defer(new Callable<ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> call() throws Exception {
                return Observable.just("hello");
            }
        });

• interval( )方式
  创建一个按固定时间间隔发射整数序列的Observable，可用作定时器。即按照固定1秒一次调用onNext()方法。

 Observable<Long> observable = Observable.interval(1, TimeUnit.SECONDS);
 observable.subscribe(new Observer<Long>() {
           @Override
           public void onSubscribe(Disposable d) {

           }

           @Override
           public void onNext(Long value) {
               Log.e("tag",""+value);     //每隔1S打印一次value
           }

           @Override
           public void onError(Throwable e) {

           }

           @Override
           public void onComplete() {

           }
       });

• range( )方式
  创建一个发射特定整数序列的Observable，第一个参数为起始值，第二个为发送的个数，如果为0则不发送，负数则抛异常。上述表示发射11到20的数。即调用10次nNext()方法，依次传入11-20数字。

Observable<Integer> observable = Observable.range(11,10);

• timer( )方式
  创建一个Observable，它在一个给定的延迟后发射一个特殊的值，即表示延迟2秒后，调用onNext()方法。

Observable<Integer> observable = Observable.timer(2, TimeUnit.SECONDS);

• repeat( )方式
  创建一个Observable，该Observable的事件可以重复调用。

Observable<Integer> observable = Observable.just(123).repeat();

除了Observable(被观察者)的创建之外，RxJava 2.x 还提供了多个函数式接口 ，用于实现简便式的观察者模式。以Consumer为例，我们可以实现简便式的观察者模式：

Observable.just("hello").subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        });

其中Consumer中的accept()方法接收一个来自Observable的单个值。Consumer就是一个观察者。其他函数式接口可以类似应用。
除此之外，RxJava中还有许多操作符。操作符就是用于在Observable和最终的Observer之间，通过转换Observable为其他观察者对象的过程，修改发出的事件，最终将最简洁的数据传递给Observer对象。下面我们介绍一些比较常用的操作符。

操作符

• map()操作符
  map()操作符，就是把原来的Observable对象转换成另一个Observable对象，同时将传输的数据进行一些灵活的操作，方便Observer获得想要的数据形式。

Observable<Integer> observable = Observable.just("hello").map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return s.length();
            }
        });

• flatMap()操作符
  flatMap()对于数据的转换比map()更加彻底，如果发送的数据是集合，flatmap()重新生成一个Observable对象，并把数据转换成Observer想要的数据形式。它可以返回任何它想返回的Observable对象。

Observable<Object> observable = Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        });

• filter()操作符
  filter()操作符根据test()方法中，根据自己想过滤的数据加入相应的逻辑判断，返回true则表示数据满足条件，返回false则表示数据需要被过滤。最后过滤出的数据将加入到新的Observable对象中，方便传递给Observer想要的数据形式。

Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).filter(new Predicate<Object>() {
            @Override
            public boolean test(Object s) throws Exception {
                String newStr = (String) s;
                if (newStr.charAt(5) - '0' > 5) {
                    return true;
                }
                return false;
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println((String)o);
            }
        });

• take()操作符
  take()操作符：输出最多指定数量的结果。

Observable.just(list)
          .flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
           })
           .take(5).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object s) throws Exception {
                System.out.println((String)s);
            }
        });

• doOnNext()操作符
  doOnNext()允许我们在每次输出一个元素之前做一些额外的事情。

Observable.just(list)
          .flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        })
           .take(5)
           .doOnNext(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println("准备工作");
            }
        })
           .subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object s) throws Exception {
                System.out.println((String)s);
            }
        });

以上就是RxJava常用的创建方式和操作符，记录下常用的东西，方便以后查询使用。