RXAndroid

最新推荐文章于 2022-11-18 18:06:39 发布
最新推荐文章于 2022-11-18 18:06:39 发布
阅读量205 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feixiangba_xiaoniao/article/details/70161015
版权
1、merge操作符，合并观察对象
    @Test
    public void testMerge() {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        list1.add("1");
        list1.add("2");
        list1.add("3");

        list2.add("a");
        list2.add("b");
        list2.add("c");

        Observable observable1 = Observable.from(list1);
        Observable observable2 = Observable.from(list2);

        //合并数据  先发送observable2的全部数据，然后发送 observable1的全部数据
        Observable observable = Observable.merge(observable2, observable1);

        observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "rx-- " + o);
            }
        });

    }
2、zip 操作符，合并多个观察对象的数据。并且允许 Func2（）函数重新发送合并后的数据
    @Test
    public void testZip() {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        list1.add("1");
        list1.add("2");
        list1.add("3");

        list2.add("a");
        list2.add("b");
        list2.add("c");
        list2.add("d");

        Observable observable1 = Observable.from(list1);
        Observable observable2 = Observable.from(list2);

        Observable observable3 = Observable.zip(observable1, observable2, new Func2<String, String, String>() {
            @Override
            public String call(String s1, String s2) {
                return s1 + s2;
            }
        });

        observable3.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "zip-- " + o);
            }
        });
    }
3、scan累加器操作符的使用
    @Test
    public void testScan() {
        Observable observable = Observable.just(1, 2, 3, 4, 5);
        observable.scan(new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer o, Integer o2) {
                return o + o2;
            }
        }).subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "scan-- " + o);
            }
        });

    }
4、filter 过滤操作符的使用
    @Test
    public void testFilter() {
        Observable observable = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable.filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer o) {
                //数据大于4的时候才会被发送
                return o > 4;
            }
        }).subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "filter-- " + o);
            }
        });
    }
5、 消息数量过滤操作符的使用

// take ：取前n个数据
// takeLast：取后n个数据
// first 只发送第一个数据
// last 只发送最后一个数据
// skip() 跳过前n个数据发送后面的数据
// skipLast() 跳过最后n个数据，发送前面的数据

    @Test
    public void testTake() {
        //take 发送前3个数据
        Observable observable = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable.take(3)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("take-- " + o);
                        Log.i("lxm", "take-- " + o);
                    }
                });

        //takeLast 发送最后三个数据
        Observable observable2 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable2.takeLast(3)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("takeLast-- " + o);
                        Log.i("lxm", "takeLast-- " + o);
                    }
                });

        //first 只发送第一个数据
        Observable observable3 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable3.first()
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("first-- " + o);
                        Log.i("lxm", "first-- " + o);
                    }
                });

        //last 只发送最后一个数据
        Observable observable4 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable4.last()
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("last-- " + o);
                        Log.i("lxm", "last-- " + o);
                    }
                });

        //skip() 跳过前2个数据发送后面的数据
        Observable observable5 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable5.skip(2)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("skip-- " + o);
                        Log.i("lxm", "skip-- " + o);
                    }
                });

        //skipLast() 跳过最后两个数据，发送前面的数据
        Observable observable6 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable6.skipLast(2)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("skipLast-- " + o);
                        Log.i("lxm", "skipLast-- " + o);
                    }
                });
    }
6、elementAt 、elementAtOrDefault
    @Test
    public void testElement() {
        //elementAt() 发送数据序列中第n个数据 ，序列号从0开始
        //如果该序号大于数据序列中的最大序列号，则会抛出异常，程序崩溃
        //所以在用elementAt操作符的时候，要注意判断发送的数据序列号是否越界

        Observable observable7 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable7.elementAt(3)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("elementAt-- " + o);
                        Log.i("lxm", "elementAt-- " + o);
                    }
                });

        //elementAtOrDefault( int n , Object default ) 发送数据序列中第n个数据 ，序列号从0开始。
        //如果序列中没有该序列号，则发送默认值
        Observable observable9 = Observable.just(1, 2, 3, 4, 5);
        observable9.elementAtOrDefault(0, 666)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("elementAtOrDefault-- " + o);
                        Log.i("lxm", "elementAtOrDefault-- " + o);
                    }
                });
    }
7、startWith() 插入数据
    @Test
    public void testStartWith() {
//插入普通数据
//startWith 数据序列的开头插入一条指定的项 , 最多插入9条数据
        Observable observable = Observable.just("aa", "bb", "cc");
        observable
                .startWith("11", "22")
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("startWith-- " + o);
                        Log.i("lxm", "startWith-- " + o);
                    }
                });

//插入Observable对象
        List<String> list = new ArrayList<>();
        list.add("ww");
        list.add("tt");
        observable.startWith(Observable.from(list))
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("startWith2 -- " + o);
                        Log.i("lxm", "startWith2-- " + o);
                    }
                });
    }
8. delay操作符，延迟数据发送
    @Test
    public void testDelay() {
        Observable<String> observable = Observable.just("1", "2", "3", "4", "5", "6", "7", "8");

        //延迟数据发射的时间，仅仅延时一次，也就是发射第一个数据前延时。发射后面的数据不延时
        observable.delay(3, TimeUnit.SECONDS)  //延迟3秒钟
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        Log.i("lxm", "delay-- " + o);
                    }
                });

        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
7.定时器
    @Test
    public void testTimer() {
        //5秒后输出 hello world , 然后显示一张图片
        Observable.timer(5, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        System.out.println("timer--hello world " + aLong);
                        Log.i("lxm", "timer ---" + aLong);
                    }
                });
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
8.testInterval
    @Test
    public void testInterval() {

        //参数一：延迟时间  参数二：间隔时间  参数三：时间颗粒度
        Observable observable = Observable.interval(3000, 3000, TimeUnit.MILLISECONDS);
        Subscription subscription = observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println("interval-  " + o);
                Log.i("lxm", "interval");
            }
        });
    }
9、doOnNext() 操作符，在每次 OnNext() 方法被调用前执行
    @Test
    public void testDoNext() {
        Observable observable = Observable.just("1", "2", "3", "4");
        observable.doOnNext(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println("doOnNext--缓存数据" + o);
                Log.i("lxm", "doOnNext--缓存数据" + o);
            }
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
                Log.i("lxm", "onCompleted--");
            }

            @Override
            public void onError(Throwable e) {
                Log.i("lxm", "onError--");
            }

            @Override
            public void onNext(Object o) {
                System.out.println("onNext--" + o);
                Log.i("lxm", "onNext--" + o);
            }
        });
    }
10、Buffer 操作符

//
// Buffer( int n ) 把n个数据打成一个list包，然后再次发送。
// Buffer( int n , int skip) 把n个数据打成一个list包，然后跳过第skip个数据。
// 使用场景：一个按钮每点击3次，弹出一个toast

    @Test
    public void testBuffer() {
        List<String> list = new ArrayList<>();
        for (int i = 1; i < 10; i++) {
            list.add("" + i);
        }

        Observable<String> observable = Observable.from(list);
        observable
                .buffer(2)   //把每两个数据为一组打成一个包，然后发送
                .subscribe(new Action1<List<String>>() {
                    @Override
                    public void call(List<String> strings) {
                        System.out.println("buffer---------------");
                        Log.i("lxm", "buffer.....");
                        Observable.from(strings).subscribe(new Action1<String>() {
                            @Override
                            public void call(String s) {
                                System.out.println("buffer data --" + s);
                                Log.i("lxm", "buffer data --" + s);
                            }
                        });
                    }
                });
    }
11、throttleFirst 操作符

// 在一段时间内，只取第一个事件，然后其他事件都丢弃。
// 使用场景：1、button按钮防抖操作，防连续点击 2、百度关键词联想，在一段时间内只联想一次，防止频繁请求服务器
// 这段代码，是循环发送数据，每秒发送一个。throttleFirst( 3 , TimeUnit.SECONDS ) 在3秒内只取第一个事件，其他的事件丢弃。

    @Test
    public void testThrottleFirst() {

        Observable.interval(1, TimeUnit.SECONDS)
                .throttleFirst(3, TimeUnit.SECONDS)
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        System.out.println("throttleFirst--" + aLong);
                        Log.i("lxm", "throttleFirst --" + aLong);
                    }
                });

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
14、distinct 过滤重复的数据
    @Test
    public void testDistinct() {

        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("1");
        list.add("3");
        list.add("4");
        list.add("2");
        list.add("1");
        list.add("1");

        Observable.from(list)
                .distinct()
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.println("distinct--" + s);
                        Log.i("lxm", "distinct --" + s);
                    }
                });
    }
15. distinctUntilChanged() 过滤连续重复的数据
    @Test
    public void testDistinctUntilChanged() {

        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("1");
        list.add("3");
        list.add("4");
        list.add("4");
        list.add("2");
        list.add("1");
        list.add("1");

        Observable.from(list)
                .distinctUntilChanged()
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.println("distinctUntilChanged--" + s);
                        Log.i("lxm", "distinctUntilChanged --" + s);
                    }
                });
    }
16.DoOnSubscribe()
    @Test
    public void testDoOnSubscribe() {
//        doOnSubscribe()
//        使用场景： 可以在事件发出之前做一些初始化的工作，比如弹出进度条等等
//        注意：
//        1、doOnSubscribe() 默认运行在事件产生的线程里面，然而事件产生的线程一般都会运行在 io 线程里。那么这个时候做一些，更新UI的操作，是线程不安全的。
//
//        所以如果事件产生的线程是io线程，但是我们又要在doOnSubscribe() 更新UI ， 这时候就需要线程切换。
//
//        2、如果在 doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。
//
//        3、 subscribeOn() 事件产生的线程 ； observeOn() : 事件消费的线程

        Observable.just("1111", "2222", "3333").create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.i("lxm", ".....");
            }
        }).doOnSubscribe(new Action0() {
            @Override
            public void call() {
                Log.i("lxm", "call");
            }
        }).subscribeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread()) // 指定主线程
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i("lxm", "xxxxx = " + s);
                    }
                });
    }
17.Range
    @Test
    public void testRange() {
        Observable.range(10, 20)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i("lxm", "" + integer);
                    }
                });
    }
18.map
@Test
    public void testMap() {

        List<Course> courses = new ArrayList<>();
        courses.add(new Course("course111", "000000001"));
        courses.add(new Course("course222", "000000002"));
        courses.add(new Course("course333", "000000003"));
        courses.add(new Course("course444", "000000004"));
        Student[] students = {new Student("1111", "0001", 20, courses),
                new Student("2222", "0002", 21, courses),
                new Student("3333", "0003", 22, courses),
                new Student("4444", "0004", 23, courses)};

        Observable.from(students)
                .map(new Func1<Student, List<Course>>() {
                    @Override
                    public List<Course> call(Student student) {
                        Log.i("lxm", "student=" + student.getName());
                        return student.getCourse();
                    }
                })
                //被观察者处于新io线程
//                .subscribeOn(Schedulers.io())
                //观察者处于主线程
//                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<Course>>() {
                    @Override
                    public void call(List<Course> courses) {
                        Log.i("lxm", "course size = " + courses.size());
                        for (int i = 0; i < courses.size(); i++) {
                            Log.i("lxm", "观察者:" + courses.get(i).getCourseId() + ":" + courses.get(i).getCourseName());
                        }
                    }
                });
    }
19.flatMap
    @Test
    public void testFlatMap() {

        List<Course> courses = new ArrayList<>();
        courses.add(new Course("course111", "000000001"));
        courses.add(new Course("course222", "000000002"));
        courses.add(new Course("course333", "000000003"));
        courses.add(new Course("course444", "000000004"));
        Student[] students = {new Student("1111", "0001", 20, courses),
                new Student("2222", "0002", 21, courses),
                new Student("3333", "0003", 22, courses),
                new Student("4444", "0004", 23, courses)};

        Observable.from(students)
                .flatMap(new Func1<Student, Observable<Course>>() {
                    @Override
                    public Observable<Course> call(Student student) {
                        return Observable.from(student.getCourse());
                    }
                })
                .subscribe(new Action1<Course>() {
                    @Override
                    public void call(Course course) {
                        Log.i("lxm", "course = " + course.getCourseName());
                    }
                });
    }
feixiangba_xiaoniao
关注
RxJava使用Observable.zip的Iterable参数
laigengsong的博客
05-29 4981
Observable.zip zip函数允许你传入多个请求，然后合并出另外的结果传出来，普通的用法就不多说了，网上一堆介绍的 然后做项目时有个疑问点，Observable.zip如果传入一个列表，合并列表里的所有请求的时候，请求回来的顺序是未知的，返回回来的数组是否会按传入时的顺序返回回来呢。于是做了以下实验： Integer[] skuSerials={1,2,3,4,5}; ArrayList<Observable<Integer>> requestList=new Array
RxJava基础学习3-合并操作符
~~代码中的南城故事，南城故事里的中分女王。
05-11 771
1.zip 操作符 * 把多个Observable合并后，并且把这些Observable的数据进行转换再发射出去。转换之后的数据数目由最短数据长度的那个Observable决定。发射完最终会自动调用观察者的onComplete方法() * * 如以下代码： 数据长度为6的observable1和数据长度为4的observable2进行合并转换后，观察者只接收到4个数据 */ Observable observable1 = Observabl...
Rxjava(结合类)-Zip
new_abc的专栏
11-01 3806
通过一个函数将多个Observables的发射物结合到一起，基于这个函数的结果为每个结合体发 射单个数据项。 Zip 操作符返回一个Obversable，它使用这个函数按顺序结合两个或多个Observables发射 的数据项，然后它发射这个函数返回的结果。它按照严格的顺序应用这个函数。它只发射与 发射数据项最少的那个Observable一样多的数据 demo
RxJava：zip命令的使用
qq_23049111的博客
01-26 3625
使用zip方法可以把多个类型不同的数据源Observable合并为一个类型的数据源Observable。 public static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, final Func2<? super T1, ? super T2, ? extends R> zipFunction) 举个例子： 我.
第一次发干货Observable.zip与Observable.forkJoin
weixin_30872789的博客
07-13 1139
　　在IT界已经混了5年了，5年中浏览了不少的网站，在上面查询自己想要的东西，解决工作中遇到的问题，心里总想有天自己能够有自己的博客，能给分享一些自己在生活中、工作中遇到的问题，让其他有类似经历的朋友能够少走弯路，今天终于鼓起勇气在博客园写下第一篇随笔。其他不做过多的介绍，下面将介绍今天在工作中遇到的一些问题。 　　项目中用到了Angular5，其中遇到了需要同时发起两个request查询结果，...
RxAndroid Demo
05-15
**RxAndroid 深度解析** RxAndroid 是一个专门为 Android 开发者设计的库，它将 ReactiveX（响应式编程）的概念引入到 Android 应用程序中。ReactiveX 是一种编程范式，允许开发者通过观察者模式处理事件和数据流，...
RxAndroid2.0.1
06-28
最新RxAndroid2.0.1 Jar包，本人找了好久才找到，给同样需要的人一个方便。
Rxandroid 安卓
08-27
Rxandroid
RxAndroid操作符Demo
10-12
在Android开发中，RxAndroid库将反应式编程的威力带入了这个平台，极大地提高了代码的可读性和可维护性。RxAndroid是RxJava的扩展，专门为Android环境设计，使得异步操作变得更加简单和优雅。在这个"RxAndroid操作符...
MVP+Retrofit+RxAndroid使用
05-16
在Android开发中，MVP（Model-View-Presenter）架构模式、Retrofit网络库和RxAndroid库是常见的组合，它们可以有效地提升应用的可维护性和性能。本篇将详细讲解这三个技术的使用方法及其结合应用。 **MVP架构模式**...
Rxjava并行执行耗时操作使用zip和merge
zhang106209的博客
11-18 2038
Rxjava使用执行并发操作，如同时写入多个大文件，获取同时请求
RxJava配合Retrofit2使用之Observable.zip
u013139425的博客
03-11 7203
看大神的demo记录分享一下，直接上代码//通用的Rx线程转换类public class RxSchedulers { static final ObservableTransformer schedulersTransformer = new ObservableTransformer() { @Override public ObservableSo...
RxJava2.0第四篇之 zip、concat 、merge 合并发送器
mwthe的博客
09-20 1万+
来来来，说一下事件合并，合二为一，上面的都有合并之意，但也有各的特色之在； ----------------------------------------zip-以小(发射器B)为主----------------------------------------------- public static &lt;T1, T2, R&gt; Observable&lt;R&gt; zip(...
Android之RxAndroid2、RxJava2的zip应用场景及示例
Zhang Phil
05-12 6153
Android之RxAndroid2、RxJava2的zip应用场景及示例RxAndroid2、RxJava2的zip操作目的是为了合并两个Observable并最终发射一个单一的Observable结果。应用场景：比如在Android APP的开发中，涉及到和后台接口交互，网络请求结果往往不是单一的一次成型完成所有操作，以一个用户登录并获取用户头像Bitmap的流程为例。第一阶段、先登录成功
Android RxJava2(三)组合操作符
好好学习 天天向上
06-06 1721
Rxjava由于其基于事件流的链式调用、逻辑简洁 &amp;amp;amp;amp; 使用简单的特点，深受各大 Android开发者的欢迎。因此在学习过程中全面的了解了下RxJava的组合操作符。 merge() mergeArray() concat() concatArray() startWith() &amp;amp;amp;amp; startWithArray() mergeArrayDelayError() &amp;amp;amp;amp; c...
Rxjava中的zip操作
u010746364的博客
05-25 3848
http://www.jianshu.com/p/2d32f9db0e50 下面的这个项目就使用了zip转换操作。 https://github.com/gzsll/TLint/ @Provides @PerActivity Observable provideNotificationObservable(GameApi mGameApi, ForumApi mF
（四）RxJava操作符：zip数据合并操作
lei小歪的窝
03-29 1万+
使用场景:         当某界面内容来源不同，但需同时显示出来时         eg1:    一部分数据来自本地，一部分来自网络 Observable.zip( queryContactsFromLocation(), queryContactsForNet(), new Func2, List, List>() {
RxJava（九）zip 操作符在 Android 中的实际使用场景
热门推荐
Chiclaim
06-08 2万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
RxJava开发精要6 - 组合Observables
Mr.Simple的专栏
01-13 9322
上一章中，我们学到如何转换可观测序列。我们也看到了`map()`,`scan()`,`groupBY()`,以及更多有用的函数的实际例子，它们帮助我们操作Observable来创建我们想要的Observable。
rxAndroid的 简单使用
最新发布
05-05
RxAndroid 是基于 RxJava 的一个用于 Android 平台的响应式编程框架，它可以帮助我们更加方便地处理异步事件。下面是 RxAndroid 的简单使用示例： 1. 添加依赖 首先，在项目的 build.gradle 文件中添加以下依赖： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值