RXJava 2.0 操作符的使用

最新推荐文章于 2021-06-04 16:29:38 发布
最新推荐文章于 2021-06-04 16:29:38 发布
阅读量203 收藏
点赞数
分类专栏： android 开发积累
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangjiamingboke/article/details/80916777
版权 
public class RxjavaXU {
    @Test
    public void Flowable() throws Exception {
        //背压使用
        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> e) throws Exception {
                for (int i = 0; i < 1000000000; i++) {
                    e.onNext(i);
                }

            }
            //背压的模式
            /**
             * * MISSING
             顾名思义，就是当你上游一股脑的抛下来很多东西的时候，我就只接一部分，其他的我都miss掉。
             * ERROR
             当下游无法再继续接受请求的时候会抛出异常MissingBackpressureException
             上游，你拼命抛吧，我这边要是拿不下了，我就报警，老子不干了！
             * BUFFER
             上游不断的发出onNext请求，直到下游处理完
             上游，你抛吧，我就屯着，实在不行了，系统崩溃，咱俩同归于尽
             * DROP
             如果下游已经溢出了，会丢弃掉溢出了的onNext请求。
             上游，你就拼命抛吧，我这里就拿那么多，我处理完了我再去你最新的里面拿
             * LATEST
             如果下游已经溢出了，会丢弃掉溢出了的onNext请求，但是会在内部缓存一个最新的onNext请求，在下一次请求的时候会把这个最新的先返回出去。
              有，任何形式的转载都请联系作者获得授权并注明出处。
             */
        }, BackpressureStrategy.BUFFER).subscribe(new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                s.request(100);

            }

            @Override
            public void onNext(Integer integer) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(integer);
            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    //---------转换操作符--------------------------------------


    @Test
    public void empty() throws Exception {
        Observable.empty()
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        System.out.println("直接调用");
                    }
                });
    }

    @Test
    public void map() throws Exception {
        Observable.just("111")
                .map(new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) throws Exception {
                        return 1;
                    }
                }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer bitmap) {
                System.out.println(bitmap);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    @Test
    public void flatMap() throws Exception {

        Observable.just("getToken", "login")
                .flatMap(new Function<String, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(String s) throws Exception {
                        //执行完下面的以后才往下执行，没有执行完不会往下执行
                        return creatRespence(s);
                    }
                }).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Object o) {
                System.out.println(o.toString());
            }


            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

    }

    private ObservableSource<?> creatRespence(final String s) {

        return Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                Thread.sleep(2000);
                e.onNext("登录" + s);
            }
        });
    }

    @Test
    public void groupBy() throws Exception {
        //分书的例子
        Observable.just(1, 2, 3, 4, 5)
                .groupBy(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return integer > 2 ? "A类书籍" : "B类书籍";
                    }
                })
                .subscribe(new Consumer<GroupedObservable<String, Integer>>() {
                    @Override
                    public void accept(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) throws Exception {
                        stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
                            @Override
                            public void accept(Integer integer) throws Exception {
                                String key = stringIntegerGroupedObservable.getKey();
                                System.out.println(key + integer);

                            }
                        });
                    }
                });
    }

    @Test
    public void range() throws Exception {
        //数据累加
        Observable.range(1, 10)
                .scan(new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) throws Exception {
                        return integer + integer2;
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        System.out.println(integer);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });


    }

    @Test
    public void buffer() throws Exception {
        //如果你有10000条数据要插入数据库，你慢慢插，时间太久，可以使用，多少条插入一次
        Observable.just(1, 2, 3, 4, 5, 6)
                .buffer(5)//5条插入一次
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(List<Integer> integers) {
                        System.out.println(integers);
                    }

                    @Override
                    public void onError(Throwable e) {


                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

    //---------过滤操作符--------------------------------------


    @Test
    public void Filter() throws Exception {
        Observable.just(1, 2, 3, 4, 5)
                //过滤操作符
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        //大于2的才要
                        if (integer > 2) {
                            return true;
                        }
                        return false;
                    }
                }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                System.out.println(integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

    }

    @Test
    public void take() throws Exception {
        //每隔一秒钟 ，时间单位
        //这个API要RXAndroid 才有效果
        Observable.interval(1, TimeUnit.SECONDS)
                .take(5)//控制数量，超过5个执行onComplete  完成
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        System.out.println("onSubscribe");
                    }

                    @Override
                    public void onNext(Long aLong) {
                        System.out.println(aLong);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        System.out.println("完成");
                    }
                });
    }

    @Test
    public void distinct() throws Exception {
        //去除重复的元素
        Observable.just(1, 2, 2, 4, 5, 3, 4, 5, 6)
                .distinct()//去重
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        System.out.println("--->" + integer);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

    }

    @Test
    public void elementAt() throws Exception {
        Observable.just(1, 2, 2, 4, 5, 3, 4, 5, 6)
                .elementAt(5)//过滤了重复的之后，只处理第五个
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        //本来是1,2,4,5,3,6
                        System.out.println(integer);//打印3
                    }
                });
    }

    //------------条件操作符----------------------


    @Test
    public void All() throws Exception {
        Observable.just(1, 2, 3, 4, 5)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 2;//里面的东西全部都大于2，有一个不满足都false
                    }
                }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                System.out.println(aBoolean);
            }
        });

    }

    @Test
    public void contains() throws Exception {
        Observable.just(1, 2, 3, 4, 5, 6)
                .contains(3)//里面的数据是否有3，是就true
//                .any(new Predicate<Integer>() {
//                    @Override
//                    public boolean test(Integer integer) throws Exception {
//                        return integer == 3;//与contains一样的，里面可以写逻辑
//                    }
//                })
//                .isEmpty()//是否有时间
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        System.out.println(aBoolean);
                    }
                });
    }

    @Test
    public void skipWhile() throws Exception {
        //要在android下执行，才有效果
        //                       开始     结束       延时多久发      间隔多久执行下一个时间
        Observable.intervalRange(0, 5, 1, 100, TimeUnit.MILLISECONDS)
                .skipWhile(new Predicate<Long>() {
                    @Override
                    public boolean test(Long aLong) throws Exception {
                        return aLong < 2;//少于2，不下发处理，注意：如果是true,不下发处理
                    }
                })//调过一段数据
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        System.out.println(aLong);//1,2小于上面的条件不处理，结果为：3,4,5
                    }
                });
    }


    //-------------合并操作符-------------------


    @Test
    public void startWith() throws Exception {

        Observable.just(1, 2, 3, 4, 5, 6)
                //先发送他的数据，中间插入数据
                .startWith(Observable.just(2, 3, 1, 2, 3, 9))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println(integer);
                    }
                })
        ;
    }

    @Test
    public void collect() throws Exception {
        //最多加入4个Observable，超过了就不行了
        Observable.concat(Observable.just(1, 2, 3)
                , Observable.just(4, 5, 6))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println(integer);
                    }
                });
    }

    @Test
    public void merge() throws Exception {
        Observable<Integer> just1 = Observable.just(1, 2, 3);
        Observable<Integer> just2 = Observable.just(4, 5, 6);
        Observable<Integer> just3 = Observable.just(7, 8, 9);
        //按照里面的顺序执行
        Observable.merge(just1, just2, just3).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println(integer);//123456789
            }
        });

        //下面延时，并行执行 需要android  执行
//        Flowable.merge(Flowable.intervalRange(1, 5, 1000, 100, TimeUnit.MILLISECONDS),
//                Flowable.intervalRange(6, 10, 1000, 100, TimeUnit.MILLISECONDS))
//                .subscribe(new Consumer<Long>() {
//                    @Override
//                    public void accept(Long o) throws Exception {
//                        System.out.println(o);
//                    }
//                });

    }

    @Test
    public void mergeDelayError() throws Exception {
        //如果中途有发生错误，延时执行
        Flowable.mergeDelayError(
                Flowable.create(new FlowableOnSubscribe<Publisher<?>>() {
                    @Override
                    public void subscribe(FlowableEmitter<Publisher<?>> e) throws Exception {
                        e.onError(new NullPointerException());//延迟抛异常
                    }
                }, BackpressureStrategy.BUFFER)
                , Flowable.intervalRange(1, 5, 1000, 100, TimeUnit.MILLISECONDS))
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        System.out.println(o.toString());
                    }
                });
    }

    @Test
    public void zip() throws Exception {
        Flowable.zip(
                Flowable.just(1, 2, 3)//
                , Flowable.just(4, 5, 6)
                , Flowable.just(4, 3)//如果数量不同
                , new Function3<Integer, Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2, Integer integer3) throws Exception {
                        return integer + integer2 + integer3;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println(integer);//如果上面的数据长度不同，最后一个不处理
            }
        });
    }

    //-----错误操作符---------------


    @Test
    public void onErrorALL() throws Exception {
        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                for (int i = 0; i < 10; i++) {
                    if (i == 2) {
                        e.onError(new Throwable("出现错误"));
                    } else {
                        e.onNext(i + "");
                    }
                }
            }
        }, BackpressureStrategy.BUFFER)
                .onErrorReturn(new Function<Throwable, String>() {
                    //当出现错误的时候可以返回一个结果弥补一下，然后立马停止往下执行
                    @Override
                    public String apply(Throwable throwable) throws Exception {
                        Log.e("----", "处理错误信息：" + throwable.toString());
                        //上面发生异常，返回一个弥补的结果
                        return "弥补错误的结果";
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("----", "正确的数据：" + s);

            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e("----", "出现错误的数据》》" + throwable.getMessage());
            }
        });


        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                for (int i = 0; i < 10; i++) {
                    if (i == 2) {
                        e.onError(new Throwable("出现错误"));
                    } else {
                        e.onNext(i + "");
                    }
                }
            }
        }, BackpressureStrategy.BUFFER)
                .onErrorResumeNext(new Function<Throwable, Publisher<? extends String>>() {
                    @Override
                    public Publisher<? extends String> apply(Throwable throwable) throws Exception {
                        Log.e("----", "处理错误信息：" + throwable.toString());
                        //上面发生异常(使用下面的备用方案)
                        return Flowable.just("从新定义1个发源", "从新定义2个发源", "从新定义3个发源");
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("----", "正确的数据：" + s);
            }
        });

        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                for (int i = 0; i <= 5; i++) {
                    if (i == 2) {
                        //注意这里是Exception
                        e.onError(new Exception("出现错误了"));
                    } else {
                        e.onNext(i + "");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                e.onComplete();
            }
        }).onExceptionResumeNext(new Observable<String>() {
            @Override
            protected void subscribeActual(Observer<? super String> observer) {
                observer.onNext("替换出现错误的信息");
                observer.onComplete();
            }
        }).subscribe(new io.reactivex.functions.Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("---", "--》》" + s);
            }
        });


        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                for (int i = 0; i <= 9; i++) {
                    if (i == 2) {
                        e.onError(new Exception("出现错误了"));
                    } else {
                        e.onNext(i + "");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }

                e.onComplete();
            }
        }).subscribeOn(Schedulers.newThread())
//            .retry(new Predicate<Throwable>() {
//            @Override
//            public boolean test(Throwable throwable) throws Exception {
//                Log.e("--", "retry错误: "+throwable.toString());
                    //返回假就是不让重新发射数据了，调用观察者的onError就终止了。
                    //返回真就是让被观察者重新发射请求
//                return false;
//            }
//        })
//             .retry(new BiPredicate<Integer, Throwable>() {
//                 @Override
//                 public boolean test(Integer integer, Throwable throwable) throws Exception {
//                     //integer错误次数
//                     Log.e("--", "retry错误: "+integer);
//                     return true;
//                 }
//             })
                //重连第几次
                .retry(3, new Predicate<Throwable>() {
                    @Override
                    public boolean test(Throwable throwable) throws Exception {

                        return true;
                    }
                })
                .subscribeOn(Schedulers.newThread()).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("--", "收到消息: " + s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e("--", "结果错误: " + throwable.toString());
            }
        });


    }
huangjiamingboke
关注
专栏目录
RxJava2 Flowable mergeWith 合并操作符
无问西东的博客
11-23 3580
目录 1 mergeWith接口 2 mergeWith图解 3 mergeWith示例 1 mergeWith接口 Flowable<T> mergeWith(Publisher<? extendsT>other) Flattens this and another Publisher into a single Publisher, witho...
RxJava2.0操作符详解
qq_43093708的博客
03-06 560
Rxjava2.0概述 通过前面的文章介绍，读者对RxJava2.0应该有了初步的认识。RxJava2.0相对1.0没有增加新的功能，最大的变化是把原来与背压有关的操作符抽取出来放在Flowable中处理；另外2.0的接口定义更符合ReactiveStream的规范。操作符的功能和1.0相比没有太大的变化，不过Flowable是背压相关的功能抽离出来的，本篇我们来详细分析下各种操作符的作用和用法...
android 响应类型,Android拾萃 - RxJava５种响应类型的区别和背压（三）
weixin_39789690的博客
05-31 278
本文首先会给出ReactiveX的核心操作符列表和对应的文档链接，后面会具体的介绍和实践所有的操作符。如果想实现自己的操作符，可以参考：实现自定义操作符创建操作用于创建Observable的操作符Create — 通过调用观察者的方法从头创建一个ObservableDefer — 在观察者订阅之前不创建这个Observable，为每一个观察者创建一个新的ObservableEmpty/Never/...
android mvp内存溢出,android - 如何在MVP架构中为android“工作管理器”创建模块？ - 堆栈内存溢出...
weixin_30474629的博客
06-04 154
我正在编写一个运行一系列备份工作的Android应用程序。 我使用workmanager在后台执行此操作。 现在如何在MVP实现WorkManager ？ 以下是工作人员模块@Modulepublic class WorkerModule {private final Worker mworker;public WorkerModule(Worker worker) {mworker = w...
Rx_java（6）Rx_java2操作符(debounce 、filter 、switchMap )介绍-搜索功能小案例
a260724032的博客
04-10 350
转载至：https://blog.csdn.net/cn_1937/article/details/78979669 写在前面 本篇将通过一个实例-在输入框输入关键字，从网络获取数据，来讲解Rxjava的几个操作符debounce、filter、switchMap。 本案列还将使用Rxbinding2来完成。 搜索的传统方式和弊端 一般来说，我们会监听EditText空间，但数据发生变化后，...
RxJava2系列实践之倒计时功能(三)
weixin_33871366的博客
11-07 313
前言　　通过本系列前两篇的学习，相信各位码友已经基本掌握RxJava2怎么使用了，本篇我们一起来通过一个小例子实践一下，也可以加深印象。来看看如何使用RxJava2的intervalRange操作符实现倒计时功能。　　 依赖　　首先添加依赖，Demo中使用了ButterKnife注入，各版本以当前最新的为准。 dependencies { ...... compile 'io.re...
word源码java-RxJava2.0:RxJava2.0使用介绍，官方文档翻译
06-05
RxJava2.0使用介绍，参考官方文档，每个操作符对应一个示例，帮助更好理解RxJava2.0 RxJava是什么？ Rx（Reactive Extensions）历史 是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源...
RxJava2.0在android开发中的实用操作符总结
04-14
本文将深入探讨RxJava2.0的一些实用操作符，帮助开发者更好地理解和运用这个强大的工具。 1. **创建Observable** - `just()`: 用于从单个或多个值创建Observable。 - `fromArray()`: 将数组转换为Observable，...
RxJava2.0（初学者教程+实用操作符总结及原理简析）
最新发布
06-21
本教程将针对初学者，详细介绍如何入门RxJava2.0以及常用的操作符，并对其实现原理进行简要分析。 首先，让我们澄清一点：学习RxJava2.0并不需要先了解RxJava1.0。尽管两者之间存在一些差异，但核心思想保持一致，...
Android-rxjava2.0和retrofit2.0兼容的网络框架的封装
08-13
将RxJava2.0与Retrofit2.0结合，可以借助Retrofit的CallAdapter来创建一个返回类型为Observable的接口方法，这样Retrofit就会把网络请求转换为Observable对象，我们可以订阅这个Observable，从而利用RxJava提供的...
给初学者的RxJava2.0教程(三)
qq_28563283的博客
03-27 447
前言 上一节讲解了线程调度, 并且举了两个实际中的例子, 其中有一个登录的例子, 不知大家有没有想过这么一个问题, 如果是一个新用户, 必须先注册, 等注册成功之后再自动登录该怎么做呢. 很明显, 这是一个嵌套的网络请求, 首先需要去请求注册, 待注册成功回调了再去请求登录的接口. 我们当然可以想当然的写成这样: private void login() {
RxJava2 Flowable 静态操作符
无问西东的博客
10-02 6663
RxJava的学习成本其实蛮高的，我写RxJava这个系列是希望缩短学习RxJava的时间，我这里完全根据官网来学习一遍，写用例，做笔记，对于对英文不太感冒的同学，我相信看我的博客可以舒服不少！ 国庆两天假初步整理了一下Flowable的静态操作符，后续将会继续写Flowable的实例操作符，Observable、Single、Completable、Maybe操作符以及对各操作符的分类和总结，...
RxJava 2.0 使用详解
热门推荐
苦逼的程序猿☺
11-29 4万+
前言在上一篇博客中，提到了RxJava的一些比较核心的东西，还有与1.x版本的一些区别！ 现在我们具体了解一下它的使用！使用最基本的的使用我们知道一个简单的RxJava的应用，需要一个观察者或者订阅者Observer，一个被观察者Observable，最后调用subscribe()方法将两者绑定起来！ 示例：//创建观察者或者订阅者 Observer observer = new
RxJava现学现用下（应用场景）
DDUP的博客
11-08 699
前言 之前两篇文章介绍了RxJava常用的操作符，本文将从实际开发着手，来聊聊RxJava的应用场景。再聊这个之前，先回顾一下RxJava的操作符： 如上图所示，RxJava基本分为这6类操作符，下面针对这6类操作符，具体介绍一下应用场景。 学习内容： 提示：这里可以添加要学的内容 例如： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 提示：这里可以添加计划学习的时间 例如： 1、 周一至周五晚上 7 点—晚上9点 2、
Hement：项目中的三方依赖（四）
weixin_34191734的博客
12-11 210
GitHub地址：Hement:持续更新中 由于使用Dagger2的未知性，所以创建一个分支没有使用Dagger2 Hement 1、RxPermissions 版本0.10.2 使用方式 初始化 RxPermissions mRxPermissions = new RxPermissions(this); 复制代码 请求两个权限的代码 //连续获取两个权限以上 ...
轮询器几秒后每隔多少秒执行一次
qq_44624237的博客
10-21 1244
// 轮询器 开启页面5秒后 每隔10秒走一次 mdDisposable = Flowable.interval(5, 10, TimeUnit.SECONDS) .doOnNext(new Consumer<Long>() { @Override public void accept(Long integer) throws Exception { .
3章 RxJava操作符
点击置顶文章查看博客目录（全站式导航）
12-07 1260
课程地址 RxJava2从入门到精通-初级篇:https://edu.csdn.net/course/detail/10036 RxJava2从入门到精通-中级篇:https://edu.csdn.net/course/detail/10037 RxJava2从入门到精通-进阶篇:https://edu.csdn.net/course/detail/10038 RxJava2从入门到精通-源码...
RxJava学习
zuimeirensheng的博客
11-02 1033
Google 无人车之父带你进入无人驾驶之域http://cn.udacity.com/course/intro-to-self-driving-cars--nd113 前言 最近学习了一下RxJava，发现是个好东西，有点相见恨晚的感觉，一开始学习了RxJava 1.x，看了很多国内的博客，有点理解了，后来发现现在都 2.x 了，于是各种搜索，最后发现Season_zlc写的系列教程通俗易懂
"RxJava2.0初学者教程：实用操作符总结与原理简析
本教程旨在帮助初学者了解RxJava2.0，包括实用操作符的总结及原理简析。随着RxJava2正式版发布，国内关于其资料相对较少，对于以前使用过RxJava1的人来说，只需要阅读更新文档就能掌握如何使用RxJava2；然而对于以前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值