RxJava操作符学习备忘

来源：互联网发布：扫描识别文字软件编辑：程序博客网时间：2024/05/18 01:58

操作符学习

create：最基本的创建Observable方法,ObservableEmitter用于发送事件并且可以可以上下游的订阅关系是否被切断

  Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> e) throws Exception {              if (!e.isDisposed()) {                    e.onNext(1);                    e.onNext(2);                    e.onNext(3);                    e.onComplete();                }            }        })

2.just:创建一个依次发送事件的Observable对象的

3.Map:用于包装转换事件

   observable.map(new Function<Integer, String>() {                    @Override                    public String apply(Integer integer) throws Exception {                        Log.i(TAG, "apply Thread:" + Thread.currentThread().getName());                        return "soilder" + integer;                    }                })

4.FlatMap:用于将事件拆分成多个事件进行发送,但是不能确保事件的先后顺序

observable. .flatMap(new Function<Integer, ObservableSource<String>>() {                    @Override                    public ObservableSource<String> apply(Integer integer) throws Exception {                        Log.i(TAG, "apply Thread:" + Thread.currentThread().getName());                        ArrayList<String> arrayList = new ArrayList<String>();                        for (int i = 0; i < 3; i++) {                            String s = "to be Number" + integer;                            arrayList.add(s);                        }                        return Observable.fromIterable(arrayList).delay(1000, TimeUnit.MILLISECONDS);//通过延时就可以发现是无序的                    }                })

5.concatMap类似与flatMap,但是确保事件的发送是严格有序的
6.switchMap也与concatMap类似,一样是保证事件的顺序的,不同是如果数据源Observable产生A、B、C三个结果，通过switchMap的自定义映射规则，映射后应该会产生A1、A2、B1、B2、C1、C2，但是在产生B2的同时，C1已经产生了，这样最后的结果就变成A1、A2、B1、C1、C2，B2被舍弃掉了

7.zip组合事件将两个事件源组合成一个事件源

 Observable<Integer> observable1 = Observable.range(1, 3).subscribeOn(Schedulers.io());        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {            @Override            public void subscribe(ObservableEmitter<String> e) throws Exception {                debugLog("subscribe Thread:" + Thread.currentThread());                e.onNext("Student");                e.onNext("Student");                e.onNext("Student");                e.onNext("Student");                e.onComplete();            }        }).subscribeOn(Schedulers.newThread());        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {            @Override            public String apply(Integer integer, String s) throws Exception {                return s + integer;            }        })

8.buffer(int size,int skip),设置长度为start的缓冲区,每次跳过skip个

Observable.just("one", "two", "three", "four", "five").buffer(3, 2).subscribe(new Observer<List<String>>() {            @Override            public void onSubscribe(Disposable d) {                Log.d(TAG, " onSubscribe : " + d.isDisposed());            }            @Override            public void onNext(List<String> stringList) {                debugLog(" onNext size : " + stringList.size());                Log.d(TAG, " onNext : size :" + stringList.size());                for (String value : stringList) {                    debugLog(" value : " + value);                }            }            @Override            public void onError(Throwable e) {                debugLog(" onError : " + e.getMessage());            }            @Override            public void onComplete() {                debugLog(" onComplete");            }        }); //打印的结果为"one", "two", "three" //"three", "four", "five" //"five"

9.Completable观察者类,只能发送完成事件的观察者

Completable.create(new CompletableOnSubscribe() {            @Override            public void subscribe(CompletableEmitter e) throws Exception {                e.onComplete();            }        }).subscribe(new CompletableObserver() {            @Override            public void onSubscribe(Disposable d) {                debugLog(" onSubscribe ");            }            @Override            public void onComplete() {                debugLog(" onComplete ");            }            @Override            public void onError(Throwable e) {                debugLog(" onError ");            }        });

10.filter过滤,用于筛选调不需要的事件

11.debounce每产生一个结果后一定事件段内没产生新的事件就把事件交给下游处理,如果有新的事件那就把新的事件交给下游处理.计时起点会重置为被发送的事件的起点.(这个方法记时起点都是事件的发送的时间点)
,操作即时搜索框的时候非常使用

 Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> e) throws Exception {                // send events with simulated time wait                e.onNext(1); // skip                Thread.sleep(400);                e.onNext(2); // deliver                Thread.sleep(505);                e.onNext(3); // skip                Thread.sleep(100);                e.onNext(4); // deliver                Thread.sleep(605);                e.onNext(5); // deliver                Thread.sleep(510);                e.onComplete();            }        }).debounce(500, TimeUnit.MILLISECONDS)                .observeOn(Schedulers.io())                .subscribeOn(AndroidSchedulers.mainThread())                .subscribe(new Observer<Integer>() {                    @Override                    public void onSubscribe(Disposable d) {                        debugLog(" onSubscribe ");                    }                    @Override                    public void onNext(Integer value) {                        debugLog(" onNext ");                        debugLog(" value: " + value);                    }                    @Override                    public void onError(Throwable e) {                        debugLog(" onError ");                    }                    @Override                    public void onComplete() {                        debugLog(" onComplete ");                    }                });

12.defer操作符其实效果与create操作符相同,当然create方法你需要手动发送onComplete事件,defer不同于just,from等操作符在创建被观察者对象的时候就已经存储了事件对象,他在发送时候事件的内容才确定事件的内容因此可以获取到最新的事件对象,对于对象类型的事件来说just与defer效果是一样的这设计java深拷贝浅拷贝的问题

13.CompositeDisposable与subscribeWith.subscribeWith用于返回Disposable对象,CompositeDisposable用于存储Disposable对象,CompositeDisposable对象通过调用clear方法切断所有被观察者和观察者之间的联系.

14.distinct方法用于去除重复的事件

15.reduce方法用于累加累减去累乘等功能

16.类似与计时器的功能interval(long initialDelay, long period, TimeUnit unit)

17.last(T t)当上游没发送事件的时候发送一个默认的事件

18.merge把两个数据源头整合成一个数据源,不改变事件发送的先后顺序

19.lift()操作符,高阶的底层的一个操作符,当现有的操作符满足不了需求时候就可以尝试使用lift,里面使用的代理模式实现,但一般不建议使用,容易发生意料不到的错误.一般尽量使用常用的操作符号

20.compose用于转换Observable的方法,当对一组的Observable的进行一连串flat,Map的变换的的时候就需要使用Compose;

 Observable observable1=Observable.just(1,2,3).map(integer -> integer+"A")                .delay(100,TimeUnit.MILLISECONDS)                .filter(s -> s.contains("1"));Observable observable2=Observable.just(9,12,14).map(integer -> integer+"A")                .delay(100,TimeUnit.MILLISECONDS)                .filter(s -> s.contains("1"));Observable observable3=Observable.just(8,5,14).map(integer -> integer+"A")                .delay(100,TimeUnit.MILLISECONDS)                .filter(s -> s.contains("1"));.......

当然可以写成这样:

   public void PretreatmentObservable(Observable<Integer> ob){        ob.map(integer -> integer+"A")                .delay(100,TimeUnit.MILLISECONDS)                .filter(s -> s.contains("1"));;    }PretreatmentObservable(Observable.just(1,2,3))PretreatmentObservable(Observable.just(9,12,14))PretreatmentObservable(Observable.just(8,5,14)) .......

为了保持链式操作可以使用compose()

ObservableTransformer<Integer,String>  transform=new ObservableTransformer<Integer, String>(){            @Override            public ObservableSource apply(Observable<Integer> upstream) {                return upstream.map(new Function<Integer,String>() {                    @Override                    public String apply(Integer i ) throws Exception {                        return i+"A";                    }                }).filter(new Predicate<String>() {                    @Override                    public boolean test(String s) throws Exception {                        return s.contains("1");                    }                }).delay(100,TimeUnit.MILLISECONDS);            }};        Observable.just(1,2,3).compose(transform);        Observable.just(9,12,14).compose(transform);        Observable.just((8,5,14).compose(transform);.......

阅读全文

0 0