RxJava 学习进行中 -Range&GroupBy

RX

1.Range

Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度。
RxJava将这个操作符实现为range函数，它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。
range默认不在任何特定的调度器上执行。有一个变体可以通过可选参数指定Scheduler。

这个操作符还是挺简单的。

int start = 0;
int end = 30;
Observable.range(start,end, Schedulers.newThread()).subscribe(new Action1<Integer>() {
      @Override
      public void call(Integer integer) {
           Log.d("range","now = "+integer);
      }
});

在一瞬间将0~29按顺序发送出来了

Paste_Image.png

2.GroupBy

将一个Observable分拆为一些Observables集合，它们中的每一个发射原始Observable的一个子序列,GroupBy操作符将原始Observable分拆为一些Observables集合，它们中的每一个发射原始Observable数据序列的一个子序列。哪个数据项由哪一个Observable发射是由一个函数判定的，这个函数给每一项指定一个Key，Key相同的数据会被同一个Observable发射。

在GroupBy的Func1()函数中按你的逻辑分组，并将每个信息对应的组的key标志返回，如例子中我每个标志都是Integer类型的，GroupBy会返回Observable的一个特殊子类GroupedObservable，这个特殊子类有个额外的方法getKey(),可用于获得当前信息的组别。

实践出真知
先构造了三个类A，B，C，用一个List装了他们的若干个实例，随机的，再使用Observer发射出去，经过GroupBy的作用后打印结果。

        ArrayList list = new ArrayList<Object>();
        list.add(new A());
        list.add(new B());
        list.add(new C());
        list.add(new C());
        list.add(new B());
        list.add(new A());
        list.add(new C());

        Observable from = Observable.from(list);
        from.groupBy(new Func1<Object,Integer>() {
            @Override
            public Integer call(Object o) {
                String name = o.getClass().getName();
                String a = A.class.getName();
                String b = B.class.getName();
                String c = C.class.getName();
                if (name.equals(a)){
                    return  1;
                }else if(name.equals(b)){
                    return  2;
                }else if(name.equals(c)){
                    return  3;
                }
                return 4;
            }
        }).subscribe(new Action1<GroupedObservable<Integer,Object>>() {
            @Override
            public void call(GroupedObservable<Integer,Object> objectIntegerGroupedObservable) {
                int sign = objectIntegerGroupedObservable.getKey();

                switch (sign){
                    case 1:
                        objectIntegerGroupedObservable.subscribe(new Action1<Object>() {
                            @Override
                            public void call(Object a) {
                                Log.d("groupby","class A - "+a.getClass().getName());
                            }
                        });
                        break;
                    case 2:
                        objectIntegerGroupedObservable.subscribe(new Action1<Object>() {
                            @Override
                            public void call(Object a) {
                                Log.d("groupby","class B - "+a.getClass().getName());
                            }
                        });

                        break;
                    case 3:
                        objectIntegerGroupedObservable.subscribe(new Action1<Object>() {
                            @Override
                            public void call(Object a) {
                                Log.d("groupby","class C - "+a.getClass().getName());
                            }
                        });

                        break;
                    default:
                        Log.d("groupby","other class");
                        break;
                }
            }
        });

Paste_Image.png

groupBy(Func1 func1,Func1 func2)
作用跟单个参数的差不多，唯一差别是第二个Func1()则是用来变换返回的信息的

如果将上面的groupBy()换成：

        from.groupBy(new Func1<Object, Integer>() {
            @Override
            public Integer call(Object o) {
                String name = o.getClass().getName();
                String a = A.class.getName();
                String b = B.class.getName();
                String c = C.class.getName();
                if (name.equals(a)){
                    return  1;
                }else if(name.equals(b)){
                    return  2;
                }else if(name.equals(c)){
                    return  3;
                }
                return 4;
            }
        }, new Func1<Object, Integer>() {
            @Override
            public Integer call(Object o) {
                String name = o.getClass().getName();
                String a = A.class.getName();
                String b = B.class.getName();
                String c = C.class.getName();
                if (name.equals(a)){
                    return  1;
                }else if(name.equals(b)){
                    return  2;
                }else if(name.equals(c)){
                    return  3;
                }
                return 4;
            }
        }).subscribe(new Action1<GroupedObservable<Integer,Object>>() {
            @Override
            public void call(GroupedObservable<Integer,Object> objectIntegerGroupedObservable) {
                //...略...
            }
        });

结果打印的信息的类型都是Integer了

Paste_Image.png
因为我们第二个Func1()返回的是Integer类型。

官方文档说的挺粗浅的，但只有你实际运用到手上了才能更深刻的理解它能做什么。