Rxjava2基础概念和操作符

最新推荐文章于 2024-06-18 04:12:39 发布
最新推荐文章于 2024-06-18 04:12:39 发布
阅读量354 收藏 3
点赞数 1
分类专栏： Android 架构篇 文章标签： android rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014158743/article/details/114885454
版权

文章目录

RxJava概念与观察者模式

RxJava的上游与下游

流程整理 1
// 上游 Observable 被观察者
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                // 发射
                Log.d(TAG, "上游 subscribe: 开始发射..."); // todo 2
                emitter.onNext("RxJavaStudy");

                emitter.onComplete(); // 发射完成  // todo 4

                // 上游的最后log才会打印
                Log.d(TAG, "上游 subscribe: 发射完成");
            }
        }).subscribe(
         // 下游 Observer 观察者
         new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                // 弹出 加载框 ....
                Log.d(TAG, "上游和下游订阅成功 onSubscribe 1"); // todo 1
            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "下游接收 onNext: " + s); // todo 3
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                // 隐藏加载框
                Log.d(TAG, "下游接收完成 onComplete"); // todo 5  只有接收完成之后，上游的最后log才会打印
            }
        });
        
        /**
         *  结论：
         *  D/MainActivity: 上游和下游订阅成功 onSubscribe 1
         *  D/MainActivity: 上游 subscribe: 开始发射...
         *  D/MainActivity: 下游接收 onNext: RxJavaStudy
         *  D/MainActivity: 下游接收完成 onComplete
         *  D/MainActivity: 上游 subscribe: 发射完成
         */
流程整理 2

结论

  1. 在 onComplete();/onError 发射完成之后，下游不再接收上游的事件
  2. 已经发射了onComplete()， 再发射onError RxJava会报错，不允许
  3. 先发射onError，再onComplete();，不会报错， 有问题（onComplete不会接收到了）
流程整理 3

切断下游

Rxjava创建型操作符

create
Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
        // 上游发射的
        e.onNext("A"); // 使用者自己发射
    }
})
just
Observable.just("A", "B")

just：发射单一对象

fromArray
String[] strings = {"张三", "李四", "王五"};
Observable.fromArray(strings)

fromArray：发射数集对象

empty
// 上游无法指定 事件类型
Observable.empty() // 内部一定会只调用 发射 onComplete 完毕事件

empty：下游默认是Object，无法发出有值事件，只会发射onComplete

range
// 上游  range内部会去发射
// Observable.range(1, 8) // 1 2 3 4 5 6 7 8  从1开始加 数量共8个

range：累加

Rxjava变换型操作符

上游 -------> 变换操作(往右边流向的时候，进行变换) ----------> 下游

map

1.map 把上一层Int Int变换String 观察者String类型。

// 在上游和下游之间 变换
.map(new Function<Integer, String>() {
    @Override
    public String apply(Integer integer) throws Exception {
        // 1
        Log.d(TAG, "map1 apply: " + integer);

        return "【" + integer + "】";
    }
})
flatMap

2.flatMap 把上一层Int Int变换ObservableSource{还可以再次发射多次事件} 观察者String类型。 不排序的

// 变换操作符
.flatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(final Integer integer) throws Exception {

        // integer == 111

        // ObservableSource == 可以再次手动发送事件
        return Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext(integer + "flatMap变换操作符");
                e.onNext(integer + "flatMap变换操作符");
                e.onNext(integer + "flatMap变换操作符");
            }
        });
    }
})
// 下游的泛型是String类型的

// 体现 flatMap 变换 操作符 是不排序的
.flatMap(new Function<String, ObservableSource<?>>() { // ? 通配符 默认Object
    @Override
    public ObservableSource<?> apply(String s) throws Exception {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add(s + " 下标：" + (1 + i));
        }
        return Observable.fromIterable(list).delay(5, TimeUnit.SECONDS); // 创建型操作符，创建被观察者
    }
})
// 下游的泛型是Object类型的
concatMap

3.concatMap 把上一层Int Int变换ObservableSource{还可以再次发射多次事件} 观察者Bitmap类型。 排序的

// 体现 concatMap 变换操作符 排序的
.concatMap(new Function<String, ObservableSource<?>>() {
    @Override
    public ObservableSource<?> apply(String s) throws Exception {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add(s + " 下标：" + (1 + i));
        }
        return Observable.fromIterable(list).delay(5, TimeUnit.SECONDS); // 创建型操作符，创建被观察者
    }
})
groupBy

4.groupBy 把上一层Int Int变换String(高端配置电脑) 观察者GroupedObservable类型 {key=“高端”, 细节再包裹一层}

// 上游
Observable.just(6000, 7000, 8000, 9000, 10000, 14000)

 // 变换
.groupBy(new Function<Integer, String>() {
    @Override
    public String apply(Integer integer) throws Exception {
        return integer > 8000 ? "高端配置电脑" : "中端配置电脑"; // 分组
    }
})

// 订阅
/*.subscribe(new Consumer<String>() { // 下游 使用 groupBy
    @Override
    public void accept(String string) throws Exception {

    }
});*/

// 使用groupBy下游是 有标准的
.subscribe(new Consumer<GroupedObservable<String, Integer>>() {
    @Override
    public void accept(final GroupedObservable<String, Integer> groupedObservable) throws Exception {
        Log.d(TAG, "accept: " + groupedObservable.getKey());
        // 以上还不能把信息给打印全面，只是拿到了，分组的key

        // 输出细节，还需要再包裹一层
        // 细节 GroupedObservable 被观察者
        groupedObservable.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: 类别：" + groupedObservable.getKey() + "  价格：" + integer);
            }
        });
    }
});
buffer

5.buffer 100个事件 Integer .buffer(20) 观察者List==五个集合。
很多的数据，不想全部一起发射出去，分批次，先缓存到Buffer

// 上游
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        for (int i = 0; i < 100; i++) {
            e.onNext(i);
        }
        e.onComplete();
    }
})

// 变换 buffer
.buffer(20)

.subscribe(new Consumer<List<Integer>>() {
    @Override
    public void accept(List<Integer> integer) throws Exception {
        Log.d(TAG, "accept: " + integer);
    }
});

RxJava过滤型操作符

上游 -------> 过滤操作(往右边流向的时候，进行过滤) ----------> 下游

filter 过滤

1.filter 如果是false全部都发射给下游，如果是true，全部都不发射给下游。

.filter(new Predicate<String>() {
    @Override
    public boolean test(String s) throws Exception {
        // return true; // 不去过滤，继续传给下游
        // return false; // 过滤掉，continue下一条

        if ("三鹿".equals(s)) {
            return false; 
        }

        return true;
    }
})
// 除了“三鹿”，其他都会被发射到下游
take 过滤操作符

take ：只有再定时器运行基础上 加入take过滤操作符，才有take过滤操作符的价值。

Observable.interval(2, TimeUnit.SECONDS)// 每2s发射一次

        // 增加过滤操作符，停止定时器
        .take(8) // 执行次数达到8 停止下来

        .subscribe(new Consumer<Long>() { // 下游
            @Override
            public void accept(Long aLong) throws Exception {
                Log.d(TAG, "accept: " + aLong);
            }
        });
distinct 过滤重复事件
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        e.onNext(1);
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onNext(4);
        e.onNext(4);
        e.onComplete();
    }
})

.distinct() // 过滤重复 发射的事件

.subscribe(new Consumer<Integer>() { // 下游 观察者
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "accept: " + integer); // 事件不重复
    }
});
// 打印出1234，重复的被过滤掉了。
elementAt 操作符

4.elementAl 指定发射事件内容，如果没找到，则发射默认的事件。

// 上游
Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
        e.onNext("九阴真经");
        e.onNext("九阳真经");
        e.onNext("易筋经");
        e.onNext("神照经");
        e.onComplete();
    }
})

// 过滤操作符
.elementAt(100, "默认经") // 指定下标输出 事件

// 订阅
.subscribe(new Consumer<String>() { // 下游
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, "accept: " + s);
    }
});
// 这里是指定第100个事件，肯定不存在，所以输出默认事件

RxJava条件型操作符

如果使用了条件操作符，下一层，接收的类型 就是条件类型(Boolean)

All操作符

全部满足条件，则为true

Observable.just(v1, v2, v3, v4) // RxJava 2.X 之后 不能传递null，否则会报错

.all(new Predicate<String>() {
    @Override
    public boolean test(String s) throws Exception {
        return !s.equals("cc"); // 如果s不等于cc，就是true
    }
})

.subscribe(new Consumer<Boolean>() { // 下游 观察者
    @Override
    public void accept(Boolean s) throws Exception {
        Log.d(TAG, "accept: " + s);
    }
});
contains操作符

包含，则为true

Observable.just("JavaSE", "JavaEE", "JavaME", "Android", "iOS", "Rect.js", "NDK")

.contains("C")     // 是否包含了 Android，条件是否满足

.subscribe(new Consumer<Boolean>() {
    @Override
    public void accept(Boolean s) throws Exception {
        Log.d(TAG, "accept: " + s);
    }
});
any操作符

任意一个满足条件，为true

Observable.just("JavaSE", "JavaEE", "JavaME", "Android", "iOS", "Rect.js", "NDK")

        .any(new Predicate<String>() {
            @Override
            public boolean test(String s) throws Exception {
                return s.equals("Android");
            }
        })     // 是否包含了 Android，条件是否满足

        .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean s) throws Exception {
                Log.d(TAG, "accept: " + s);
            }
        });

RxJava合并型操作符

startWait操作符

先执行 startWait括号里面的被观察者

// 上游
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        // todo 2
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onComplete();
    }
})
.startWith(Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        // todo 1
        e.onNext(10000);
        e.onNext(20000);
        e.onNext(30000);
        e.onComplete();
    }
}))
.subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "accept: " + integer);
    }
});
//  D/MainActivity6: accept: 10000
//  D/MainActivity6: accept: 20000
//  D/MainActivity6: accept: 30000
//  D/MainActivity6: accept: 1
//  D/MainActivity6: accept: 2
//  D/MainActivity6: accept: 3
concatWith操作符

后执行 concatWait括号里面的被观察者

// 例子同上者startWith操作符，输出相反
concat操作符

是按照顺序依次执行 最多四个被观察者进行合并

// 上游 被观察者
Observable.concat(

        Observable.just("1") // todo 1
        ,
        Observable.just("2") // todo 2
        ,
        Observable.just("3") // todo 3
        ,
        Observable.create(new ObservableOnSubscribe<String>() { // todo 4
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("4");
                e.onComplete();
            }
        })

)
.subscribe(new Consumer<String>() { // 下游 观察者
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, "accept: " + s);
    }
});
// 1234
merge操作符

并列执行的，（演示并列的执行，所以学了intervalRange） 最多四个被观察者进行合并

// 被观察者1
Observable observable1 = Observable.intervalRange(1, 5, 1,2, TimeUnit.SECONDS);
// 被观察者2
Observable observable2 = Observable.intervalRange(6, 5, 1,2, TimeUnit.SECONDS); // 6 7 8 9 10
// 被观察者3
Observable observable13 = Observable.intervalRange(11, 5, 1,2, TimeUnit.SECONDS); // 11 12 13 14 15

// 上游
Observable.merge(observable1, observable2, observable13) // 合并成一个 被观察者

.subscribe(new Consumer() {
    @Override
    public void accept(Object o) throws Exception {

        // 被观察者1  1
        // 被观察者2  6
        // 被观察者3  11

        Log.d(TAG, "accept: " + o);
    }
});
// 输出：
 accept: 1
 accept: 6
 accept: 11
 accept: 2
 accept: 7
 accept: 12
 accept: 3
 accept: 8
 accept: 13
 accept: 4
 accept: 9
 accept: 14
 accept: 5
 accept: 10
 accept: 15
zip操作符

需要对应关系 需要对应，如果不对应，会被忽略的， 最多9个被观察者 进行合并

/**
 * zip 合并操作符：合并的被观察者发射的事件，需要对应
 * 需求：考试 课程 == 分数
 * @param view
 */
public void r05(View view) {

    // 课程 被观察者
    Observable observable1 = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            e.onNext("英语"); // String
            e.onNext("数学");
            e.onNext("政治");
            e.onNext("物理");  // 被忽略
            e.onComplete();
        }
    });

    // 分数 被观察者
    Observable observable2 = Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
            e.onNext(85); // Integer
            e.onNext(90);
            e.onNext(96);
            e.onComplete();
        }
    });

    // 9 被观察者
    Observable.zip(observable1, observable2, new BiFunction<String, Integer, StringBuffer>() { // T1 String, T2 Integer,  R StringBuffer
        @Override
        public StringBuffer apply(String string, Integer integer) throws Exception {
            return new StringBuffer().append("课程" + string).append("==").append(integer+"");
        }
    })
    .subscribe(/*new Consumer() {
        @Override
        public void accept(Object o) throws Exception {
            Log.d(TAG, "最终考试的结果 accept: " + o);
        }
    }*/

            new Observer() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.d(TAG, "onSubscribe: 准备进入考场，考试了....");
                }

                @Override
                public void onNext(Object o) {
                    Log.d(TAG, "onNext: 考试结果输出 " + o);
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {
                    Log.d(TAG, "onComplete: 考试全部完毕");
                }
            }
    );
}
// 输出：
onSubscribe: 准备进入考场，考试了....
onNext: 考试结果输出 课程英语==85
onNext: 考试结果输出 课程数学==90
onNext: 考试结果输出 课程政治==96
onComplete: 考试全部完毕

RxJava异常处理操作符

RxJava中是不标准的报错方式：throw new xxxException(“我要报错了”);但是也能被onErrorReturn，onErrorResumeNext，onExceptionResumeNext等操作符拦截到。
RxJava中标准的报错方式：e.onError(XXX);
throw new xxxError方式都不能拦截，程序直接奔溃。

onErrorReturn

能够接收到e.onError(Error/Exception)/throw new xxxException.
特点：能够打印异常详情，会给下游一个标记。

// 上游 被观察者
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        for (int i = 0; i < 100; i++) {
            if (i == 5) {
                // RxJava中是不标准的
                // throw new IllegalAccessException("我要报错了");

                // RxJava标准的
                e.onError(new IllegalAccessException("我要报错了")); // 发射异常事件
            }
            e.onNext(i);
        }
        e.onComplete();
    }
})

// 在上游 和 下游之间 添加异常操作符
.onErrorReturn(new Function<Throwable, Integer>() {
    @Override
    public Integer apply(Throwable throwable) throws Exception {
        // 处理，纪录，异常，通知给下一层
        Log.d(TAG, "onErrorReturn: " + throwable.getMessage());
        return 400; // 400代表有错误，给下一层，目前 下游 观察者
    }
})

.subscribe(new Observer<Integer>() { // 完整版 下游 观察者
    @Override
    public void onSubscribe(Disposable d) {

    }

    // 如果使用了 异常操作符 onNext: 400
    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "onNext: " + integer); // 400
    }

    // 如果不使用 异常操作符 onError
    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "onError: " + e.getMessage());
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "onComplete: ");
    }
});
onErrorResumeNext

能够接收到e.onError(Error/Exception)/throw new xxxException.
特点：可以重新返回一个被观察者，发射多次事件

.onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
    @Override
    public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {

        // onErrorResumeNext 返回的是 被观察者，所以再多次发射给 下游 给 观察者接收
        return Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(400);
                e.onNext(400);
                e.onNext(400);
                e.onNext(400);
                e.onNext(400);
                e.onNext(400);
                e.onComplete();
            }
        });
    }
})
onExceptionResumeNext

只能够接收到e.onError(Exception)/throw new xxxException，不接收Error。
同样可以返回一个被观察者。

// 上游
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        for (int i = 0; i < 100; i++) {
            if (i == 5) {
               /* throw new 其他Exception("错了");
                throw new IllegalAccessException("错了");*/
                throw new Exception("错了");
                // e.onError(new IllegalAccessException("错了")); // 异常事件
            } else {
                e.onNext(i);
            }

        }
        e.onComplete();
    }
})

// 在上游和下游中间 增加 异常操作符
.onExceptionResumeNext(new ObservableSource<Integer>() {
    @Override
    public void subscribe(Observer<? super Integer> observer) {
        observer.onNext(404); // 可以让程序 不崩溃的
    }
})
retry

return false; 代表不去重试 return true; 不停的重试， 演示二 重试次数， 演示三 打印重试了多少次，计数

// todo 演示一
/*.retry(new Predicate<Throwable>() {
    @Override
    public boolean test(Throwable throwable) throws Exception {
        Log.d(TAG, "retry: " + throwable.getMessage());
        // return false; // 代表不去重试
        return true; // 一直重试，不停的重试
    }
})*/

// todo 演示二 重试次数
/*.retry(3, new Predicate<Throwable>() {
    @Override
    public boolean test(Throwable throwable) throws Exception {
        Log.d(TAG, "retry: " + throwable.getMessage());
        return true;
    }
})*/

// todo 演示三 打印重试了多少次，计数     Throwable  +  count
.retry(new BiPredicate<Integer, Throwable>() {
    @Override
    public boolean test(Integer integer, Throwable throwable) throws Exception {
        Thread.sleep(2);
        Log.d(TAG, "retry: 已经重试了:" + integer + "次  e：" + throwable.getMessage());
        return true; // 重试
    }
})

架构师系列文章一览

IT小瓯
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Rxjava2的笔记1 --操作符
小Tian的博客
08-21 318
implementation 'io.reactivex.rxjava2:rxjava:2.2.6' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' 创建操作符 create :创建操作符,创建最简单的事件流 其中Consumer为自定义观察者方法,不必全部实现观察者所有方法,此accept对应onNext()方法 Observable.create(new ObservableOnSubscribe<Integer...
RxJava2常用操作符及相关类
清冷的月光的博客
06-04 661
基于RxJava 2.1.12，记录RxJava的常用操作符及相关类。 ObservableEmitter 目的 ObservableEmitter是对Observer的抽象，用于关联Observable resource。 public interface ObservableEmitter&amp;lt;T&amp;gt; extends Emitter&amp;lt;T&amp;gt; 用法...
Rxjava2操作符大全
04-24
Rxjava2操作符大全，方便你使用Rxjava2；Rxjava2操作符大全，方便你使用Rxjava2；Rxjava2操作符大全，方便你使用Rxjava2
深入浅出RxJava(二：操作符)
热门推荐
大头鬼Bruce
03-06 10万+
RxJava operator介绍，介绍了RxJava中几种常见的operator的用法
Android RxJava： 这是一份全面的 操作符 使用汇总 （含详细实例讲解）
最新发布
2401_85730018的博客
06-18 743
RxJava。
RxJava2操作符使用
u013728021的博客
04-07 659
1.基本创建 操作符 create（）RxJava 中创建被观察者对象最基本的操作符 作用：完整创建1个被观察者对象（Observable） Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() { ...
Rxjava2操作符的使用
ThinksAgain的博客
02-13 410
之前学习了一些Rxjava2的操作符在此记录一下，以后用到了方便查询 import android.os.Bundle; import android.support.annotation.NonNull; import android.support.v7.app.AppCompatActivity; import android.text.TextUtils; import android....
RxJava2系列(二) 操作符
hhxsp的博客
11-25 304
直接进入正题： Map map是RxJava中最简单的一个变换操作符了, 它的作用就是对上游发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化. 用事件图表示如下: 图中map中的函数作用是将圆形事件转换为矩形事件, 从而导致下游接收到的事件就变为了矩形.用代码来表示这个例子就是: Observable.create(new ObservableOnSubscribe<Integer>() { @Override ...
【Android】RxJava2+Retrofit2+OkHttp3的基础、封装和项目中的使用
11-29
在Android开发中，Retrofit2、RxJava2和OkHttp3是三个非常重要的库，它们共同构建了一个高效、灵活的网络请求框架。本篇文章将深入探讨这三个组件的基础知识，以及如何进行封装和在实际项目中使用。 首先，Retrofit...
组合操作符：在rxjava2中实现多个操作符的组合
在RxJava2中，有许多基础的操作符可以用来处理和转换Observable流中的数据。这些操作符能够帮助我们根据需求对数据进行过滤、变换、合并等操作，从而更加灵活地处理异步数据流。下面将介绍一些常用的基础操作符及其...
Rxjava(三)、操作符的使用
Evan的博客
04-02 484
Android进阶系列之第三方库知识点整理。 知识点总结，整理也是学习的过程，如有错误，欢迎批评指出。 第一篇：Rxjava2(一)、基础概念及使用 第二篇：Rxjava2(二)、五种观察者模式及背压 终于到操作符了，我觉得rxjava2如此好用，绝对少不了操作符的功劳，下面这张图你就简单的扫一眼，别慌，我们慢慢啃。 上一篇讲了，rxjava有五种观察者创建模式，其中Observable和F...
条件操作符：在rxjava2中根据条件进行操作
# 1. 简介 ## 1.1 介绍RxJava2 RxJava是一个基于事件...本文将从RxJava2的基础知识入手，介绍其核心概念和基本原理，然后重点讲解条件操作符在RxJava2中的作用、用法以及实际应用。接着，我们将深入理解条件操作符的
Android拾萃 - RxJava2操作符汇总
philos3的博客
10-23 899
几种主要的需求： - 直接创建一个Observable（创建操作） - 组合多个Observable（组合操作） - 对Observable发射的数据执行变换操作（变换操作） - 从Observable发射的数据中取特定的值（过滤操作） - 转发Observable的部分值（条件/布尔/过滤操作） - 对Observable发射的数据序列求值（算术/聚合操作）创建操作符
每天记录学习的新知识：RxJava2 操作符
嗯...
08-26 510
中文文档 ：https://www.kancloud.cn/luponu/rxjava_zh/974452Schedulers.computation() 用于计算任务，如事件循环或和回调处理，不要用于IO操作(IO操作请使用Schedulers.io())；默认线程数等于处理器的数量Schedulers.from(executor) 使用指定的Executor作为调度器Schedulers.single() 该调度器的线程池只能同时执行一个线程Sch
RxJava2.x学习教程（三）常用操作符
孙朝阳的博客
05-25 1426
上一篇文章介绍了，创建、转化类、过滤类、合并类的操作符RxJava2.x学习教程（二）常用操作符，本文接着学习其余操作符，如错误处理类操作符、工具类操作符，条件和布尔操作符，综合操作符，连接操作符等！ ConcatMap concatMap和flatMap的区别在于 它能保证顺序 Observable.fromArray(1,10,20) .co...
RxJava2源码分析（二）：操作符原理分析
weixin_33676492的博客
01-19 128
前言：上一篇文章RxJava2源码分析（一）：基本流程分析,是对RxJava2基本流程的分析，有了上一篇的基础，这篇就再深入一点，开始分析一下RxJava2操作符的原理。   为了方便理解RxJava2操作符的原理，这里选择最常用的map操作符来讲解操作符的原理，示例代码如下 private void basicUseRxJava() { Observable.create(...
RxJava2操作符（一）
刘信的博客
04-04 254
RxJava是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。简单来说就是异步操作工具库。它可以在碰到繁琐、复杂的异步的功能，依然能用保持代码的简洁。 RxJava使用的是观察者模式，Observable(被观察者）与Observer（观察者）通过 subscribe (订阅)实现订阅关系。下面来先写一个简单的例子。来说明他们之间的关系 /* *...
RxJava2系列(三) 操作符
hhxsp的博客
11-25 331
just just，就是一个简单的发射器依次调用onNext()方法。 Observable.just("1", "2", "3") .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Consumer<String>() { .
RxJava2.x学习教程（二）常用操作符
孙朝阳的博客
05-19 1703
**操作符 ** 操作符官方doc Create Create — create an Observable from scratch by calling observer methods programmatically 最常用的操作符，用于创建一个被观察者（发射事件）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IT小瓯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值