androidRxJava操作符（六）

条件操作符和布尔操作符

1 all

all操作符对所有Observable发射的数据进行判断，诅咒返回的结果就是这个判断结果，如果所有的判断都符合则为true 否则为false。

 Observable.just(1, 2, 3, 4)
                .all(new Func1<Integer, Boolean>()
                {
                    @Override
                    public Boolean call(Integer integer)
                    {
                        Log.e(TAG, "call:"+integer);//输出所有小于3的数
                        return integer < 3;//小于3的数
                    }
                }).subscribe(new Subscriber<Boolean>()
        {
            @Override
            public void onCompleted()
            {
                Log.e(TAG, "onCompleted:");
            }

            @Override
            public void onError(Throwable e)
            {
                Log.e(TAG, "onError:" + e.getMessage());//得到报错信息
            }

            @Override
            public void onNext(Boolean aBoolean)
            {
                Log.e(TAG, "onNext:" + aBoolean);
            }
        });

 

 

2 contains 、isEmpty

contains用来查看发射过的数据是否包含指定数据，包含则返回true 否则返回false

 Observable.just(1, 2, 3, 4, 5)
                .contains(1)//查看是否包含某一个数据 现在是查看是否包含1
                .subscribe(new Action1<Boolean>()
                {
                    @Override
                    public void call(Boolean aBoolean)
                    {
                        Log.e(TAG, "callContains:" + aBoolean);//包含则返回true 不包含则返回false
                    }
                });

 

isEmpty用来判断源Observable是否发射过该数据，发射过返回false，没发射过范湖true

 Observable.just(1, 2, 3, 4)
                .isEmpty()//用来判断是否发射过数据
                .subscribe(new Action1<Boolean>()
                {
                    @Override
                    public void call(Boolean aBoolean)
                    {
                        Log.e(TAG, "callisEmpty:" + aBoolean);//发射过返回false，没发射过返回true
                    }
                });

条件操作符

1 amb

amb只会发射首先发射出来的数据，延迟发射的数据不会被发射

    private void amb()
    {
        Observable.amb(//只会发射首先发射出来的数据，由于第一个Observable延迟两秒发射，所以不会发射
                Observable
                .just(1, 2)//第一个被观察者发射数据
                .delay(2, TimeUnit.SECONDS), Observable.just(3, 4, 5))
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "amb:" + integer);
                    }
                });
    }

2 defaultEmpty

发射原始Observable数据，如果没有发射数据，则发射指定的默认数据

 private void defaultEmptyOb()
    {
        Observable.create(new Observable.OnSubscribe<Integer>()
        {
            @Override
            public void call(Subscriber<? super Integer> subscriber)
            {
                subscriber.onCompleted();
            }
        }).defaultIfEmpty(3)//由于原始Observable没有发射数据则会发射一个指定数据3
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "defaultIfEmpty:" + integer);
                    }
                });
    }

转换操作符

1 toList

将发射的数据转换成List集合

 private void toList()
    {
        Observable.just(1,2,3,4)
                .toList()
                .subscribe(new Action1<List<Integer>>()
                {
                    @Override
                    public void call(List<Integer> integers)
                    {
                        Log.e(TAG, "toList:" + integers);
                    }
                });
    }

2 toSortedList

可以给生成的集合进行排序，，默认自然升序，如果发射的数据没有实现Comparable接口，会抛出一个异常，如果发射的数据没有实现Comparable则可以使用toSortedList（Fun2）变体。

  private void toSortedList()
    {
        Observable.just(3, 7, 6, 1)
                .toSortedList()
                .subscribe(new Action1<List<Integer>>()
                {
                    @Override
                    public void call(List<Integer> integers)
                    {
                        Log.e(TAG, "toList:" + integers);
                    }
                });
    }

3 toMap

将所有发射的数据生成一个Map（默认HaspMap）

 private void toMapOb()
    {
        Swordsman swordsman1 = new Swordsman("1111", "aaa");
        Swordsman swordsman2 = new Swordsman("2222", "SS");
        Swordsman swordsman3 = new Swordsman("3333", "X");
        Observable.just(swordsman1, swordsman2, swordsman3)
                .toMap(new Func1<Swordsman, String>()
                {
                    @Override
                    public String call(Swordsman swordsman)
                    {
                        return swordsman.getLevel();
                    }
                }).subscribe(new Action1<Map<String, Swordsman>>()
        {
            @Override
            public void call(Map<String, Swordsman> stringSwordsmanMap)
            {
                Log.e(TAG, "toMapOb:" + stringSwordsmanMap.get("SS").getName());
            }
        });
    }