RxJava操作符

来源：互联网发布：杭州淘宝摄影公司编辑：程序博客网时间：2024/06/01 09:34

本文基本属于摘抄，摘抄的地址会在文章末尾给出

buffer操作符
buffer操作符周期性地收集源Observable产生的结果到列表中，并把这个列表提交给订阅者，订阅者处理后，清空buffer列表，同时接收下一次收集的结果并提交给订阅者，周而复始。

需要注意的是，一旦源Observable在产生结果的过程中出现异常，即使buffer已经存在收集到的结果，订阅者会马上收到这个异常，buffer中的结果不会发出。

  int num = 1;    public void useBuffer(View view) {        //定义邮件内容        final String[] mails = new String[]{"Here is an email!", "Another email!", "Yet another email!"};        //每隔1秒就随机发布一封邮件        Observable<String> endlessMail = Observable.create(new Observable.OnSubscribe<String>() {            @Override            public void call(Subscriber<? super String> subscriber) {                if (subscriber.isUnsubscribed()) {                    return;                }                Random ran = new Random();                while (true) {                    String mail = mails[ran.nextInt(mails.length)];                    subscriber.onNext(mail);                    if (num == 8) {                        subscriber.onError(new Throwable("故意出错"));                    }                    num++;                    try {                        Thread.sleep(1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                        subscriber.onError(e);                    }                }            }        }).subscribeOn(Schedulers.io());        //把上面产生的邮件内容缓存到列表中，并每隔3秒通知订阅者        endlessMail.buffer(3, TimeUnit.SECONDS)                .subscribe(new Subscriber<List<String>>() {                    @Override                    public void onCompleted() {                    }                    @Override                    public void onError(Throwable e) {                        Log.e(tag, e.getMessage());                    }                    @Override                    public void onNext(List<String> list) {                        Log.e(tag, String.format("You've got %d new messages!  Here they are!", list.size()));                        for (int i = 0; i < list.size(); i++)                            Log.e(tag, "**" + list.get(i).toString());                    }                });    }

 E/tag: You've got 3 new messages!  Here they are! E/tag: **Another email! E/tag: **Yet another email! E/tag: **Here is an email! E/tag: You've got 3 new messages!  Here they are! E/tag: **Here is an email! E/tag: **Another email! E/tag: **Another email! E/tag: 故意出错

当num=8的时候，buffer的第三次收集已经收集了2次事件，但是调用subscriber.onError(new Throwable("故意出错"));后，收集的事件并没发出，而这个错误，订阅者会立即接收到。

groupBy操作符
groupBy操作符是对源Observable产生的结果进行分组，形成一个类型为GroupedObservable的结果集，GroupedObservable中存在一个方法为getKey()，可以通过该方法获取结果集的Key值

  Observable.interval(1, TimeUnit.SECONDS).take(10).groupBy(new Func1<Long, Long>() {            @Override            public Long call(Long aLong) {                return aLong % 3;            }        }).subscribe(new Action1<GroupedObservable<Long, Long>>() {            @Override            public void call(final GroupedObservable<Long, Long> result) {                result.subscribe(new Action1<Long>() {                    @Override                    public void call(Long value) {                        Log.e(tag, "key:" + result.getKey() + ", value:" + value);                    }                });            }        });

//输出结果09-18 23:03:51.908 20619-21544/? E/tag: key:0, value:009-18 23:03:52.904 20619-21544/? E/tag: key:1, value:109-18 23:03:53.904 20619-21544/? E/tag: key:2, value:209-18 23:03:54.904 20619-21544/? E/tag: key:0, value:309-18 23:03:55.904 20619-21544/? E/tag: key:1, value:409-18 23:03:56.904 20619-21544/? E/tag: key:2, value:509-18 23:03:57.904 20619-21544/? E/tag: key:0, value:609-18 23:03:58.904 20619-21544/? E/tag: key:1, value:709-18 23:03:59.904 20619-21544/? E/tag: key:2, value:809-18 23:04:00.904 20619-21544/? E/tag: key:0, value:9

scan操作符:scan操作符通过遍历源Observable产生的结果，依次对每一个结果项按照指定规则进行运算，计算后的结果作为下一个迭代项参数，每一次迭代项都会把计算结果输出给订阅者。

  Observable.just(1, 2, 3, 4, 5)                .scan(new Func2<Integer, Integer, Integer>() {                    @Override                    public Integer call(Integer sum, Integer item) {                        //参数sum就是上一次的计算结果                        return sum + item;                    }                }).subscribe(new Action1<Integer>() {            @Override            public void call(Integer integer) {                Log.e(tag, "Next: " + integer);            }        });

//输出结果 Next: 1 Next: 3 Next: 6 Next: 10 Next: 15

window操作符:window操作符非常类似于buffer操作符，区别在于buffer操作符产生的结果是一个List缓存，而window操作符产生的结果是一个Observable，订阅者可以对这个结果Observable重新进行订阅处理。

 Observable.interval(1, TimeUnit.SECONDS)                .take(12)                .window(3, TimeUnit.SECONDS)                .subscribe(new Action1<Observable<Long>>() {                    @Override                    public void call(Observable<Long> observable) {                        Log.e(tag, "subdivide begin......");                        observable.subscribe(new Action1<Long>() {                            @Override                            public void call(Long aLong) {                                Log.e(tag, "Next:" + aLong);                            }                        });                    }                });

运行结果如下： subdivide begin…… Next:0 Next:1 subdivide begin…… Next:2 Next:3 Next:4 subdivide begin…… Next:5 Next:6 Next:7 subdivide begin…… Next:8 Next:9 Next:10 subdivide begin…… Next:11

debounce操作符:debounce操作符对源Observable每产生一个结果后，如果在规定的间隔时间内没有别的结果产生，则把这个结果提交给订阅者处理，否则忽略该结果。如果源Observable产生的最后一个结果后在规定的时间间隔内调用了onCompleted,那么通过debounce操作符也会把这个结果提交给订阅者

Observable.create(new Observable.OnSubscribe<Integer>() {            @Override            public void call(Subscriber<? super Integer> subscriber) {                if(subscriber.isUnsubscribed()) return;                try {                    //产生结果的间隔时间分别为100、200、300...900毫秒                    for (int i = 1; i < 10; i++) {                        subscriber.onNext(i);                        Thread.sleep(i * 100);                    }                    subscriber.onCompleted();                }catch(Exception e){                    subscriber.onError(e);                }            }        }).subscribeOn(Schedulers.newThread())          .debounce(400, TimeUnit.MILLISECONDS)  //超时时间为400毫秒          .subscribe(                new Action1<Integer>() {                    @Override                    public void call(Integer integer) {                        System.out.println("Next:" + integer);                    }                }, new Action1<Throwable>() {                    @Override                    public void call(Throwable throwable) {                        System.out.println("Error:" + throwable.getMessage());                    }                }, new Action0() {                    @Override                    public void call() {                        System.out.println("completed!");                    }                });

distinct操作符：去掉重复值

 Observable.just(1, 1, 22, 3, 3, 4)                .distinct()                .subscribe(new Subscriber<Integer>() {                    @Override                    public void onCompleted() {                        Log.e(tag, "completed!");                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Integer integer) {                        //输出1,22,3,4                        Log.e(tag, "Next:" + integer);                    }                });

elementAt操作符：取指定位置的元素

Observable.just(1, 2, 3, 4, 5)                .elementAt(2)                .subscribe(new Subscriber<Integer>() {                    @Override                    public void onCompleted() {                        Log.e(tag, "completed!");                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Integer integer) {                        //输出3                        Log.e(tag, "elementAt Next:" + integer);                    }                });

filter操作符：对源Observable产生的结果按照指定条件进行过滤，只有满足条件的结果才会提交给订阅者

 Observable.just(1, 2, 3, 4, 5)                .filter(new Func1<Integer, Boolean>() {                    @Override                    public Boolean call(Integer integer) {                        return integer < 4;                    }                })                .subscribe(new Subscriber<Integer>() {                    @Override                    public void onCompleted() {                        Log.e(tag, "completed!");                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Integer integer) {                        //只输出1,2,3,                        Log.e(tag, "filter Next:" + integer);                    }                });

ofType操作符：按照事件的类型进行过滤，比如发送的事件类型有float，有int，还有String,可以过滤想要的类型

 Observable.just("hello", 2F, 3L, true, 'c')                .ofType(Float.class)                .subscribe(new Subscriber<Float>() {                    @Override                    public void onCompleted() {                        Log.e(tag, "ofType onCompleted:");                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Float aFloat) {                    //输出2.0                        Log.e(tag, "ofType Next:" + aFloat);                    }                });

single操作符:single操作符是对源Observable的结果进行判断，如果产生的结果满足指定条件的数量不为1(有且只有一个)则抛出异常，否则把满足条件的结果提交给订阅者

Observable.just(1, 2, 3, 4, 5)                .single(new Func1<Integer, Boolean>() {                    @Override                    public Boolean call(Integer integer) {                        return integer > 4;                    }                }).subscribe(new Subscriber<Integer>() {            @Override            public void onCompleted() {                Log.e(tag, "single onCompleted:");            }            @Override            public void onError(Throwable e) {                Log.e(tag, "single onError:" + e.getMessage());            }            @Override            public void onNext(Integer integer) {            //输出5                Log.e(tag, "single Next:" + integer);            }        });

gnoreElements操作符：ignoreElements操作符忽略所有源Observable产生的结果，只把Observable的onCompleted和onError事件通知给订阅者。ignoreElements操作符适用于不太关心Observable产生的结果，只是在Observable结束时(onCompleted)或者出现错误时能够收到通知。

 Observable.just(1, 2, 3, 4, 5)                .ignoreElements()                .subscribe(new Subscriber<Integer>() {                    @Override                    public void onCompleted() {                        Log.e(tag, "Sequence complete.");                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Integer integer) {                    //没有结果输出                        Log.e(tag, "ignoreElements Next:" + integer);                    }                });

参考链接
【1】http://blog.csdn.net/job_hesc/article/details/46495281

0 0