RxJava2 转换

最新推荐文章于 2023-03-11 19:41:42 发布
Jimmy_buer
最新推荐文章于 2023-03-11 19:41:42 发布
阅读量248
点赞数
分类专栏： Rxjava 文章标签： Rx java 转换 flatmap concatmap
本文链接：https://blog.csdn.net/qq_32508519/article/details/103509653
版权
Rxjava 专栏收录该内容
2 篇文章 0 订阅
订阅专栏
FlatMap 将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并 后放进一个单独的Observable
FlatMap 对这些Observables发射的数据做的是合并( merge )操作，因此它们可能是交 错的。
Observable.just(1, 2, 3).flatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(Integer integer) throws Exception {
        return Observable.just("变成了字符串" + integer);
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d("TakeActivity-flatMap", s);
     }
});

输出可能无序：
2019-12-12 10:38:35.574 11741-11741/com.jimmy.rx D/TakeActivity-flatMap: 变成了字符串1
2019-12-12 10:38:35.574 11741-11741/com.jimmy.rx D/TakeActivity-flatMap: 变成了字符串2
2019-12-12 10:38:35.574 11741-11741/com.jimmy.rx D/TakeActivity-flatMap: 变成了字符串3


flatMap(Func1,int))这个操作符有一个接受额外的 int 参数的一个变体。这个参数设置 flatMap 从原来的 Observable映射Observables的最大同时订阅数。当达到这个限制时，它会等待其中一个终止 然后再订阅另一个。

concatMap它类似于最简单版本的 flatMap ，但是它按次序连接而不是合 并那些生成的Observables，然后产生自己的数据序列。
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).concatMap(new Function<Integer, ObservableSource<?>>() {
    @Override
    public ObservableSource<?> apply(Integer integer) throws Exception {
        return Observable.just("转换成字符串且有循序：" + integer);
    }
}).subscribe(new Consumer<Object>() {
    @Override
    public void accept(Object o) throws Exception {
        Log.d("TakeActivity", "concatMap-o:" + o);
    }
});

输出有顺序：
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：1
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：2
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：3
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：4
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：5
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：6
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：7
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：8
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：9
2019-12-12 13:53:26.621 23639-23639/com.jimmy.rx D/TakeActivity: concatMap-o:转换成字符串且有循序：10


switchMap 操作符。它和 flatMap 很像，除了一点:当原始Observable发射 一个新的数据(Observable)时，它将取消订阅并停止监视产生执之前那个数据的 Observable，只监视当前这一个。
从流每次只能发射4个数据0-4，这是因为主流每发射一次触发了从流的发射，但是在从流发射的过程中，如果主流又一次发射了数据，switchMap会截断上一次的从流，响应本次的主流，从而开启新的一段的从流发射。
Observable.interval(0, 5, TimeUnit.SECONDS).switchMap(new Function<Long, ObservableSource<?>>() {
    @Override
    public ObservableSource<?> apply(Long aLong) throws Exception {
        Log.d("TakeActivity", "switchMap-o:主流发送的数据发送" + aLong);
        return Observable.interval(1, TimeUnit.SECONDS);
    }
}).subscribe(new Consumer<Object>() {
    @Override
    public void accept(Object o) throws Exception {
        Log.d("TakeActivity", "switchMap-o:从流开始发送数据" + o);
    }
});


输出（主流每一次发送数据都会导致从流中断然后重新开始）：
2019-12-12 14:20:45.160 25145-25224/com.jimmy.rx D/TakeActivity: switchMap-o:主流发送的数据发送0
2019-12-12 14:20:46.161 25145-25226/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据0
2019-12-12 14:20:47.160 25145-25226/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据1
2019-12-12 14:20:48.160 25145-25226/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据2
2019-12-12 14:20:49.161 25145-25226/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据3
2019-12-12 14:20:50.160 25145-25224/com.jimmy.rx D/TakeActivity: switchMap-o:主流发送的数据发送1
2019-12-12 14:20:51.162 25145-25230/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据0
2019-12-12 14:20:52.162 25145-25230/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据1
2019-12-12 14:20:53.162 25145-25230/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据2
2019-12-12 14:20:54.162 25145-25230/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据3
2019-12-12 14:20:55.162 25145-25230/com.jimmy.rx D/TakeActivity: switchMap-o:从流开始发送数据4



Map操作符对Observable发射的每一项数据应用一个函数，执行变换操作
Map 操作符对原始Observable发射的每一项数据应用一个你选择的函数，然后返回一个发射 这些结果的Observable
Observable.just(1, 2, 3, 4).map(new Function<Integer, String>() {
    @Override
    public String apply(Integer integer) throws Exception {
        return integer + "-->转化字符串";
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d("TakeActivity", "普通map" + s);
    }
});


2019-12-12 14:37:02.057 25555-25555/com.jimmy.rx D/TakeActivity: 普通map1-->转化字符串
2019-12-12 14:37:02.057 25555-25555/com.jimmy.rx D/TakeActivity: 普通map2-->转化字符串
2019-12-12 14:37:02.057 25555-25555/com.jimmy.rx D/TakeActivity: 普通map3-->转化字符串
2019-12-12 14:37:02.057 25555-25555/com.jimmy.rx D/TakeActivity: 普通map4-->转化字符串


cast 操作符将原始Observable发射的每一项数据都强制转换为一个指定的类型，然后再发射 数据，它是 map 的一个特殊版本。
用处不大。只能子类转父类。 否则会报ClassCastException：类型转换异常。
可以用来校验一系列数据是否为同一类型。 
Observable.range(1, 5).cast(Integer.class).subscribe(new Observer<Integer>() {

    @Override
    public void onError(Throwable e) {
        LogUtils.d("------>onError()" + e);
    }
    @Override
    public void onNext(Integer i) {
        Log.d("TakeActivity", "------>onNext()" + i);
    }
});

2019-12-12 15:02:56.690 30874-30874/com.jimmy.rx D/TakeActivity: ------>onNext()1
2019-12-12 15:02:56.690 30874-30874/com.jimmy.rx D/TakeActivity: ------>onNext()2
2019-12-12 15:02:56.690 30874-30874/com.jimmy.rx D/TakeActivity: ------>onNext()3
2019-12-12 15:02:56.690 30874-30874/com.jimmy.rx D/TakeActivity: ------>onNext()4
2019-12-12 15:02:56.690 30874-30874/com.jimmy.rx D/TakeActivity: ------>onNext()5




buffer操作符，定期收集Observable的数据放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一 个值。
Observable.just(1, 2, 3, 4, 5).buffer(3).subscribe(new Consumer<List<Integer>>() {
    @Override
    public void accept(List<Integer> integers) throws Exception {
        Log.d("TakeActivity", "buffer-integers:" + integers);
    }
});

输出：
2019-12-09 14:33:13.713 554-554/com.jimmy.rx D/TakeActivity: buffer-integers:[1, 2, 3]
2019-12-09 14:33:13.713 554-554/com.jimmy.rx D/TakeActivity: buffer-integers:[4, 5]

buffer(count, skip)：buffer(count, skip) 从原始Observable的第一项数据开始创建新的缓存，此后每当收
到 skip 项数据，用 count 项数据填充缓存:开头的一项和后续的 count-1 项，它以列表 (List)的形式发射缓存，取决于 count 和 skip 的值，这些缓存可能会有重叠部分(比如skip < count时)，也可能会有间隙(比如skip > count时)。
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).buffer(4, 6).subscribe(new Consumer<List<Integer>>() {
    @Override
    public void accept(List<Integer> integers) throws Exception {
        Log.d("TakeActivity", "buffer-skip-integers:" + integers);
    }
});

输出：
2019-12-09 15:45:53.443 4788-4788/com.jimmy.rx D/TakeActivity: buffer-skip-integers:[1, 2, 3, 4]
2019-12-09 15:45:53.443 4788-4788/com.jimmy.rx D/TakeActivity: buffer-skip-integers:[7, 8, 9, 10]





window操作符，定期将来自原始Observable的数据分解为一个Observable窗口，发射这些窗口，而不是每次 发射一项数据
部分功能与buffer特别类似
 window(int count)：每当当前窗口发射了 count 项数据，它就关闭 当前窗口并打开一个新窗口。如果从原始Observable收到了 onError 或 onCompleted 通知它 也会关闭当前窗口。
Observable.interval(1, TimeUnit.SECONDS).take(10).window(4)
        .subscribe(new Observer<Observable<Long>>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Observable<Long> longObservable) {
                Log.d("TakeActivity", "window-time - onNext");
                longObservable.subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d("TakeActivity", "window-time - aLong:" + aLong.longValue());
                    }
                });
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onComplete() {
                Log.d("TakeActivity", "window-time - onComplete");
            }
        });


输出：
2019-12-09 14:13:34.275 32268-32335/com.jimmy.rx D/TakeActivity: window-time - onNext
2019-12-09 14:13:34.275 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:0
2019-12-09 14:13:35.275 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:1
2019-12-09 14:13:36.275 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:2
2019-12-09 14:13:37.278 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:3
2019-12-09 14:13:38.275 32268-32335/com.jimmy.rx D/TakeActivity: window-time - onNext
2019-12-09 14:13:38.276 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:4
2019-12-09 14:13:39.276 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:5
2019-12-09 14:13:40.278 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:6
2019-12-09 14:13:41.278 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:7
2019-12-09 14:13:42.278 32268-32335/com.jimmy.rx D/TakeActivity: window-time - onNext
2019-12-09 14:13:42.279 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:8
2019-12-09 14:13:43.276 32268-32335/com.jimmy.rx D/TakeActivity: window-time - aLong:9
2019-12-09 14:13:43.276 32268-32335/com.jimmy.rx D/TakeActivity: window-time - onComplete


window(long timespan  , TimeUnit, scheduler))：。每当过了 timespan 这么长的时间它就关闭当 前窗口并打开一个新窗口(时间单位是 unit ，可选在调度器 scheduler 上执行)。如果从原 始Observable收到了 onError 或 onCompleted 通知它也会关闭当前窗口
Observable.interval(1, TimeUnit.SECONDS).take(10).window(3, TimeUnit.SECONDS)
        .subscribe(new Observer<Observable<Long>>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Observable<Long> longObservable) {
                Log.d("TakeActivity", "window-time - onNext");
                longObservable.subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d("TakeActivity", "window-time - aLong:" + aLong.longValue());
                    }
                });
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onComplete() {
                Log.d("TakeActivity", "window-time - onComplete");
            }
        });

输出：
2019-12-09 14:10:38.914 32053-32053/com.jimmy.rx D/TakeActivity: window-time - onNext
2019-12-09 14:10:39.915 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:0
2019-12-09 14:10:40.915 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:1
2019-12-09 14:10:41.915 32053-32164/com.jimmy.rx D/TakeActivity: window-time - onNext
2019-12-09 14:10:41.916 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:2
2019-12-09 14:10:42.916 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:3
2019-12-09 14:10:43.915 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:4
2019-12-09 14:10:44.915 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:5
2019-12-09 14:10:44.916 32053-32164/com.jimmy.rx D/TakeActivity: window-time - onNext
2019-12-09 14:10:45.918 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:6
2019-12-09 14:10:46.915 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:7
2019-12-09 14:10:47.918 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:8
2019-12-09 14:10:47.919 32053-32153/com.jimmy.rx D/TakeActivity: window-time - onNext
2019-12-09 14:10:48.915 32053-32153/com.jimmy.rx D/TakeActivity: window-time - aLong:9
2019-12-09 14:10:48.916 32053-32153/com.jimmy.rx D/TakeActivity: window-time - onComplete



To操作符，将Observable转换为另一个对象或数据结构
tolist
通常，发射多项数据的Observable会为每一项数据调用 onNext 方法。你可以用 toList 操作 符改变这个行为，让Observable将多项数据组合成一个 List ，然后调用一次 onNext 方法传 递整个列表。
Observable.just(1, 2, 3, 4, 5, 6).toList().subscribe(new Consumer<List<Integer>>() {
    @Override
    public void accept(List<Integer> integers) throws Exception {
        Log.d("TimeIntervalActivity", "integers-toList:" + integers);
    }
});


输出：
2019-12-04 14:16:23.103 11548-11548/com.jimmy.rx D/TimeIntervalActivity: integers-toList:[1, 2, 3, 4, 5, 6]



toSortedList
Observable.just(1, 2, 3, 4, 5, 6).toSortedList().subscribe(new Consumer<List<Integer>>() {
    @Override
    public void accept(List<Integer> integers) throws Exception {
        Log.d("TimeIntervalActivity", "toSortedList:" + integers);
    }
});



tomap
toMap 收集原始Observable发射的所有数据项到一个Map(默认是HashMap)然后发射这个 Map。你可以提供一个用于生成Map的Key的函数，还可以提供一个函数转换数据项到Map存储的值(默认数据项本身就是值)。
Observable.just(1, 2, 3, 4, 5, 6).toMap(new Function<Integer, String>() {
    @Override
    public String apply(Integer integer) throws Exception {
        return "这是key" + integer;//这里是给每一个value添加一个key。
    }
}).subscribe(new Consumer<Map<String, Integer>>() {
    @Override
    public void accept(Map<String, Integer> objectIntegerMap) throws Exception {
        for (Map.Entry<String, Integer> a : objectIntegerMap.entrySet()) {
            Log.d("TimeIntervalActivity", a.getKey() + " : " + a.getValue());
        }
    }
});

输出map：
2019-12-04 14:31:00.693 12509-12509/com.jimmy.rx D/TimeIntervalActivity: 这是key3 : 3
2019-12-04 14:31:00.693 12509-12509/com.jimmy.rx D/TimeIntervalActivity: 这是key4 : 4
2019-12-04 14:31:00.693 12509-12509/com.jimmy.rx D/TimeIntervalActivity: 这是key1 : 1
2019-12-04 14:31:00.693 12509-12509/com.jimmy.rx D/TimeIntervalActivity: 这是key2 : 2
2019-12-04 14:31:00.693 12509-12509/com.jimmy.rx D/TimeIntervalActivity: 这是key5 : 5
2019-12-04 14:31:00.693 12509-12509/com.jimmy.rx D/TimeIntervalActivity: 这是key6 : 6


toMultiMap 类似于 toMap ，不同的是，它生成的这个Map同时还是一个 ArrayList (默认是 这样，你可以传递一个可选的工厂方法修改这个行为)。
toMultiMap(Func1))这里改的是键：返回的map的value值是一个list。 如果key值相同，那么将value合并到一起。 
Observable.just(1, 2, 3, 4, 5, 6).toMultimap(new Function<Integer, Object>() {
    @Override
    public Object apply(Integer integer) throws Exception {
        switch (integer) {
            case 1:
            case 2:
            case 3:
                return "key";
            default:
                return "key1";
        }
    }
}).subscribe(new Consumer<Map<Object, Collection<Integer>>>() {
    @Override
    public void accept(Map<Object, Collection<Integer>> objectCollectionMap) throws Exception {
        Log.d("TimeIntervalActivity", objectCollectionMap.toString());
    }
});


输出：
2019-12-04 14:53:19.919 13503-13503/com.jimmy.rx D/TimeIntervalActivity: {key1=[4, 5, 6], key=[1, 2, 3]}


toMultiMap(Func1,Func1))这里改的是键值对：
Observable.just(1, 2, 3, 4, 5, 6).toMultimap(new Function<Integer, Object>() {
    @Override
    public Object apply(Integer integer) throws Exception {
        switch (integer) {//依次对每个键进行修改，键相同则合并
            case 1:
            case 2:
            case 3:
                return "key";
            default:
                return "key1";
        }
    }
}, new Function<Integer, Object>() {
    @Override
    public Object apply(Integer integer) throws Exception {
        return integer + 10;//依次对每个值进行修改
    }
}).subscribe(new Consumer<Map<Object, Collection<Object>>>() {
    @Override
    public void accept(Map<Object, Collection<Object>> objectCollectionMap) throws Exception {
        Log.d("TimeIntervalActivity", objectCollectionMap.toString());
    }
});


输出
2019-12-04 15:05:52.360 14100-14100/com.jimmy.rx D/TimeIntervalActivity: {key1=[14, 15, 16], key=[11, 12, 13]


toSortedList
默认数字升序
Observable.just(3, 1, 2, 3, 4, 5, 6).toSortedList(2).subscribe(new Consumer<List<Integer>>() {
    @Override
    public void accept(List<Integer> integers) throws Exception {
        Log.d("TimeIntervalActivity", "toSortedList:" + integers);
    }
});

输出
2019-12-05 14:55:21.788 15077-15077/com.jimmy.rx D/TimeIntervalActivity: toSortedList:[1, 2, 3, 3, 4, 5, 6]


默认升序排列，字母的ascii码
Observable.just("nihao", "zz", "hello", "hi").toSortedList().subscribe(new Consumer<List<String>>() {
    @Override
    public void accept(List<String> strings) throws Exception {
        Log.d("TimeIntervalActivity", "strings:" + strings);
    }
});

输出
2019-12-05 14:55:21.788 15077-15077/com.jimmy.rx D/TimeIntervalActivity: strings:[hello, hi, nihao, zz]


如果发 射的数据项没有实现 Comparable 接口，会抛出一个异常。
People p1 = new People(20, "hhh");
People p2 = new People(4, "yyy");
Observable.just(p1, p2).toSortedList().subscribe(new Consumer<List<People>>() {
    @Override
    public void accept(List<People> people) throws Exception {
        Log.d("TimeIntervalActivity", "people:" + people);
    }
});


输出
 Caused by: java.lang.ClassCastException: com.jimmy.rx.People cannot be cast to java.lang.Comparable


改正之后
People p1 = new People(20, "hhh");
People p2 = new People(4, "yyy");
Observable.just(p1, p2).toSortedList(new Comparator<People>() {
    @Override
    public int compare(People o1, People o2) {
        if (o1.getAge() > o2.getAge()) {
            return 1;
        } else {
            return -1;
        }
    }
}).subscribe(new Consumer<List<People>>() {
    @Override
    public void accept(List<People> people) throws Exception {
        Log.d("TimeIntervalActivity", "people:" + people.toString());
    }
});


输出
2019-12-05 15:14:47.980 19417-19417/com.jimmy.rx D/TimeIntervalActivity: people:[4yyy, 20hhh]