androidRxJava操作符（二）_flatmap cast

变换操作符

变换操作符的作用是对Observable发射的数据按照一定规则做一些变换操作，然后将变换后的数据发射出去

1 map

map错左幅通过制定一个Func对象，将Observable转换为一个新的Observable对象并发射

 private void mapOb()
    {
        Observable.just("www.qq.com").map(new Func1<String, String>()
        {//拼接成新的字符串
            @Override
            public String call(String s)
            {
                return Host + "//" + s;
            }
        }).subscribe(new Action1<String>()
        {
            @Override
            public void call(String s)
            {//输出新的字符串
                Log.e(TAG, "map:" + s);
            }
        });
    }

2 flatMap、cast

flatMap操作符将Observable发射的数据集合变换成Observable集合，然后将这些Observable发射的数据平摊化地放进一个单独的Observable。cast操作符的作用是强制将Observable发射的所有数据转换为指定类型。

  private void flatOb()
    {
        List<String> mList = new ArrayList<>();
        mList.add("111111");
        mList.add("222222");
        mList.add("333333");
        Observable.from(mList).flatMap(new Func1<String, Observable<?>>()
        {
            @Override
            public Observable<?> call(String s)
            {//将Host循环拼接11111,2222,33333,。循环次数为size
                return Observable.just(Host + s);
            }
        }).cast(String.class)//强制转换的数据类型
                .subscribe(new Action1<String>()
                {
                    @Override
                    public void call(String s)
                    {
                        Log.e(TAG, "flag:" + s);//输出拼接结果
                    }
                });
    }

3 concatMap

concatMao操作符与flag操作符一致，不过，他解决了flatMap交叉问题，提供了一种能够把发射的值连续在一起的函数，而不是合并他们。

private void caoncatOb()
    {
        final List<String> mList = new ArrayList<>();
        mList.add("111111");
        mList.add("222222");
        mList.add("333333");
        Observable.from(mList).concatMap(new Func1<String, Observable<?>>()
        {
            @Override
            public Observable<?> call(String s)
            {
                return Observable.just(Host + s);
            }
        }).cast(String.class)
                .subscribe(new Action1<String>()
                {
                    @Override
                    public void call(String s)
                    {
                        Log.e(TAG, "caoncat:" + s);//输出拼接结果
                    }
                });
    }

5 buffer 

buffer操作符将源Observable变换为一个新的Observable，这个新的Observable每次发射一组列表值而不是一个一个发射。和buffer操作弗雷斯的还有window操作符，只不过window操作符发射的是Observable而不是数据列表，

 private void bufferOb()
    {
        Observable.just(1, 2, 3, 5, 6, 7)
                .buffer(3)//缓存为3  每次发送三个
                .subscribe(new Action1<List<Integer>>()
                {
                    @Override
                    public void call(List<Integer> integers)
                    {
                        for (Integer i : integers)
                        {
                            Log.e(TAG, "buffer:" + i);//输出拼接结果
 
                        }
                        Log.e(TAG, "------------------------");//输出拼接结果
                    }
                });
    }

6 window

window用法与buffer相似，buffer发射的是一个集合列表，window发射的是一个Observable

 private void windowOb()
    {
        Observable.just(1, 2, 3, 5, 6, 7)
                .window(3)
                .subscribe(new Action1<Observable<Integer>>()
                {
                    @Override
                    public void call(Observable<Integer> integerObservable)
                    {
                        integerObservable.subscribe(new Action1<Integer>()
                        {
                            @Override
                            public void call(Integer integer)
                            {
                                Log.e(TAG, "window:" + integer);//输出拼接结果
                            }
                        });
                    }
                });
    }

7 groupBy

groupBy操作符用于分组元素，将源Observable变换成一个发射Observable的新Observable（分组后的）他们中的每一个新Observable都发射一组特定的数据。

private void grouupBy()
    {
        Swordsman s1 = new Swordsman("1", "A");
        Swordsman s2 = new Swordsman("2", "SS");
        Swordsman s3 = new Swordsman("3", "S");
        Swordsman s4 = new Swordsman("4", "S");
        Swordsman s5 = new Swordsman("5", "A");
        Swordsman s6 = new Swordsman("6", "SS");
        Swordsman s7 = new Swordsman("7", "S");
        Swordsman s8 = new Swordsman("8", "A");
        Observable<GroupedObservable<String, Swordsman>> groupedObservableObservable
                = Observable.just(s1, s2, s3, s4, s5, s6, s7, s8)
                .groupBy(new Func1<Swordsman, String>()
                {
                    @Override
                    public String call(Swordsman swordsman)
                    {
                        return swordsman.getLevel();//将相同等级的进行分组
                    }
                });
        Observable.concat(groupedObservableObservable)
                .subscribe(new Action1<Swordsman>()
                {
                    @Override
                    public void call(Swordsman swordsman)
                    {
                        Log.e(TAG, "grouupBy:" + swordsman.getName() + "/-----/" + swordsman.getLevel());//输出拼接结果  ;
                    }
                });
    }