RX操作符之辅助操作符三（using、getIterator、toFuture、toIterator、toMap、toMultiMap、nest）

最新推荐文章于 2024-03-31 16:02:26 发布

nicolelili1

最新推荐文章于 2024-03-31 16:02:26 发布

阅读量1.8k

点赞数

CC 4.0 BY-SA版权

分类专栏： RX

本文链接：https://blog.youkuaiyun.com/nicolelili1/article/details/52169757

RX 专栏收录该内容

23 篇文章

订阅专栏

本文解析了RxJava中的关键操作符，包括using、first、firstOrDefault等，并介绍了如何使用这些操作符处理数据流，还详细说明了toFuture、toIterator等阻塞式操作符的应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、using

创建一个只在Observable生命周期存在的资源

 //一个用户创建一次性资源的工厂函数
        Func0<Integer> resourceFactory = new Func0<Integer>() {

            @Override
            public Integer call() {
                return 1;
            }
        };

        //一个用于创建Observable的工厂函数
        Func1<Integer, Observable<String>> observableFactory = new Func1<Integer, Observable<String>>() {
            @Override
            public Observable<String> call(Integer integer) {
                return Observable.just(integer+"。。。。。。创建observable的工厂函数");
            }
        };

        //一个用于释放资源的函数
        Action1<Integer> disposeAction = new Action1<Integer>(){

            @Override
            public void call(Integer integer) {
                Log.e(TAG,"释放资源的函数。。。。。。。。。"+integer);
            }
        };

        Subscriber<String> subscriber = new Subscriber<String>() {

            @Override
            public void onNext(String v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        Observable.using(resourceFactory,observableFactory,disposeAction).subscribe(subscriber);

运行结果：

二、first

只发射第一项（或者满足某个条件的第一项）数据。如果你只对Observable发射的第一项数据，或者满足某个条件的第一项数据感兴趣，你可以使用First操作符。在某些实现中，First没有实现为一个返回Observable的过滤操作符，而是实现为一个在当时就发射原始Observable指定数据项的阻塞函数。在这些实现中，如果你想要的是一个过滤操作符，最好使用Take(1)者ElementAt(0)。

在一些实现中还有一个Single操作符。它的行为与First类似，但为了确保只发射单个值，它会等待原始Observable终止（否则，不是发射那个值，而是以一个错误通知终止）。你可以使用它从原始Observable获取第一项数据，而且也确保只发射一项数据。

在RxJava中，这个操作符被实现为first，firstOrDefault和takeFirst。可能容易混淆，BlockingObservable也有名叫first和firstOrDefault的操作符，它们会阻塞并返回值，不是立即返回一个Observable。

三、firstOrDefault

firstOrDefault与first类似，但是在Observagle没有发射任何数据时发射一个你在参数中指定的默认值。

四、single

single操作符也与first类似，但是如果原始Observable在完成之前不是正好发射一次数据，它会抛出一个NoSuchElementException。

五、singleOrDefualt

和firstOrDefault(T, Func1)类似，如果没有数据满足条件，返回默认值；如果有多个数据满足条件，以错误通知终止。

六、getIterator

getIterator操作符只能用于BlockingObservable的子类，要使用它，你首先必须把原始的Observable转换为一个BlockingObservable。可以使用这两个操作符：BlockingObservable.from或the Observable.toBlocking。将observable转成数据结果iterator类型，然后可以按iterator来获取数据。是阻塞式的，当有observable发出时才会输出数据。

每隔1s打印一个数据

 BlockingObservable<Long> blockingObservable = BlockingObservable.from(Observable.interval(1,TimeUnit.SECONDS).take(5));
        Iterator<Long> iterator = blockingObservable.getIterator();

        while (iterator.hasNext()){
            Log.e(TAG,"发出的数据是..............." + iterator.next());
        }

运行结果：

七、toFuture

toFuture操作符也是只能用于BlockingObservable。这个操作符将Observable转换为一个返回单个数据项的Future，如果原始Observable发射多个数据项，Future会收到一个IllegalArgumentException；如果原始Observable没有发射任何数据，Future会收到一个NoSuchElementException。如果你想将发射多个数据项的Observable转换为Future，可以这样用：myObservable.toList().toBlocking().toFuture()。

发射了多个数据，产生了异常

 BlockingObservable<Long> blockingObservable = BlockingObservable.from(Observable.interval(1,TimeUnit.SECONDS).take(5));

        Future<Long> future = blockingObservable.toFuture();
        long l = -1;
        try {
            l = future.get();
        }catch (Exception e){

        }
        Log.e(TAG,"应该获取到的数据是....................."+l);

运行结果：

2.发送Observable集合，这个过程是阻塞的，当5s后才输出数据结果

 Future<List<Long>> futureList = Observable.interval(1, TimeUnit.SECONDS).take(5).toList().toBlocking().toFuture();

        List<Long> list= null;
        try {
            list = futureList.get();
            for(long l : list){
                Log.e(TAG,"取到的数据是....................."+l);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

运行结果：

八、toIterator

将observable转成数据类型iterable，阻塞式。toFuture操作符也是只能用于BlockingObservable。这个操作符将Observable转换为一个Iterable，你可以通过它迭代原始Observable发射的数据集。

Iterable<List<Long>> iterableList = Observable.interval(1, TimeUnit.SECONDS).take(5).toList().toBlocking().toIterable();

        Iterator<List<Long>> iteratorLists = null;
        List<Long> list = null;
        try {
            iteratorLists = iterableList.iterator();
            while (iteratorLists.hasNext()) {
                list = iteratorLists.next();
            }
            for(long l : list){
                Log.e(TAG,"取到的数据是....................."+l);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

九、toList

将Observable转成数据类型list，阻塞式。通常，发射多项数据的Observable会为每一项数据调用onNext方法。你可以用toList操作符改变这个行为，让Observable将多项数据组合成一个List，然后调用一次onNext方法传递整个列表。

如果原始Observable没有发射任何数据就调用了onCompleted，toList返回的Observable会在调用onCompleted之前发射一个空列表。如果原始Observable调用了onError，toList返回的Observable会立即调用它的观察者的onError方法。

十、toMap

将Observable转成数据类型map，阻塞式。toMap收集原始Observable发射的所有数据项到一个Map（默认是HashMap）然后发射这个Map。你可以提供一个用于生成Map的Key的函数，还可以提供一个函数转换数据项到Map存储的值（默认数据项本身就是值）。

 Observable<Map<String, Long>> observable = Observable.interval(1, TimeUnit.SECONDS).take(5).toMap(new Func1<Long, String>() {
            @Override
            public String call(Long aLong) {
                return aLong + "";
            }
        });

        Subscriber<Map<String, Long>> subscriber = new Subscriber<Map<String, Long>>() {

            @Override
            public void onNext(Map<String, Long> map) {
                Set<Map.Entry<String, Long>> set =  map.entrySet();
                for(Map.Entry entry:set) {
                    Log.e(TAG, "onNext.................key:" + entry.getKey()+"...............value:"+entry.getValue());
                }
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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


        observable.subscribe(subscriber);

运行结果：

十一、toMultiMap

toMultiMap类似于toMap，不同的是，它生成的这个Map同时还是一个ArrayList（默认是这样，你可以传递一个可选的工厂方法修改这个行为）。toMultiMap默认不在任何特定的调度器上执行。

 Observable<Map<String, Collection<Long>>> observable = Observable.interval(1, TimeUnit.SECONDS).take(5).toMultimap(new Func1<Long, String>() {
            @Override
            public String call(Long aLong) {
                return "testMultiMap" + aLong;
            }
        });

        Subscriber<Map<String, Collection<Long>>> subscriber = new Subscriber<Map<String, Collection<Long>>>() {

            @Override
            public void onNext(Map<String, Collection<Long>>map) {
                Set<Map.Entry<String, Collection<Long>>> set =  map.entrySet();
                for(Map.Entry entry:set) {
                    Log.e(TAG, "onNext.................key:" + entry.getKey()+"...............value:"+entry.getValue());
                }
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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


        observable.subscribe(subscriber);

运行结果：

十二、toSortedList

oSortedList类似于toList，不同的是，它会对产生的列表排序，默认是自然升序，如果发射的数据项没有实现Comparable接口，会抛出一个异常。然而，你也可以传递一个函数作为用于比较两个数据项，这是toSortedList不会使用Comparable接口。

十三、nest

nest操作符有一个特殊的用途：将一个Observable转换为一个发射这个Observable的Observable。

 Observable<String> observable = Observable.just("nest1","nest2","nest3","nest4","nest5");
        final Subscriber<String> subscriber1 = new Subscriber<String>() {

            @Override
            public void onNext(String v) {
                Log.e(TAG, "onNext<String>................." + v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        Subscriber<Observable<String>> subscriber = new Subscriber<Observable<String>>() {

            @Override
            public void onNext(Observable<String> v) {
                Log.e(TAG, "onNextObservable<String>................." + v.subscribe(subscriber1));
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        Observable<Observable<String>> observable1  = observable.nest();
        observable1.subscribe(subscriber);

运行结果：