RxJava之常用操作符整理

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

创建方式

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,20);

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常用的创建方式和操作符，记录下常用的东西，方便以后查询使用。

秒客网

RxJava之常用操作符整理

创建方式

操作符

相关文章