Operators(操作符)（创建、转换操作符）

Operators(操作符)：其实质是函数式编程中的高阶函数，是对响应式编程的各个过程拆分和封装后的产物，以便于我们操作数据流 。

在RxJava 2.x版本中，rxjava种类划分:

创建操作符：Observable.create(), Observable.just(), Observable.fromXXX(), Observable.defer();

转换操作符：Observable.map(), Observable.flatMap(), Observable.buffer(), Observable.concatMap();

过滤操作符：Observable.filter(), Observable.sample(), Observble.take();

组合操作符：Observable.join(), Observable.merge(), Observable.combineLatest();

条件运算符：Observable.amb(), Observable.contains(), Observable.skipUtil();

功能性操作符：Observable.subscribeOn(), Observable.observeOn(), Observable.delay();

错误处理操作符：Observable.onErrorResumeNext(), Observable.retry();

数学运算及聚合操作符：Observable.count(), Observable.reduce(), Observable.concat();

其他：Observable.toList(), Observable.publish().

代码实现:
<创建操作符>
    @Test
    public void testOperatorCreates() {
    
        Observable.create(Emitter ->{
            Emitter.onNext(123);
        }).subscribe(value -> System.out.println("<create> emitter value is: " + value));
        
        System.out.println();
        Observable.just(1,2,3,4,5)
        .subscribe(value -> System.out.println("<just> emitter value is: " + value));
        
        Observable.just("First message, Hello RxJava","This is the second message")
        .subscribe(value -> System.out.println("<just> emitter value is: " + value));
        
        System.out.println();
        Observable.fromCallable(() ->{
            return Observable.just(10,20,30,40,50);
        })
        .subscribe(emitter -> System.out.println("<fromCallable> emitter value is: " + emitter));
        
        System.out.println();
        Observable.defer(() ->{
            return Observable.just(11,12,13,14,15);
        }).subscribe(emitter -> System.out.println("<defer> emitter value is: " + emitter));
        
        System.out.println();
        Integer[] array = {21,22,23,24,25};
        Observable.fromArray(array).subscribe(emitter -> System.out.println("<fromArray> emitter value is: " + emitter));
    }

    执行结果：
    <create> emitter value is: 123

    <just> emitter value is: 1
    <just> emitter value is: 2
    <just> emitter value is: 3
    <just> emitter value is: 4
    <just> emitter value is: 5
    <just> emitter value is: First message, Hello RxJava
    <just> emitter value is: This is the second message

    <fromCallable> emitter value is: io.reactivex.internal.operators.observable.ObservableFromArray@233c0b17

    <defer> emitter value is: 11
    <defer> emitter value is: 12
    <defer> emitter value is: 13
    <defer> emitter value is: 14
    <defer> emitter value is: 15

    <fromArray> emitter value is: 1
    <fromArray> emitter value is: 2
    <fromArray> emitter value is: 3
    <fromArray> emitter value is: 4
    <fromArray> emitter value is: 5

<转换操作符>
    @Test
    public void testOperatorChange() {
        System.out.println("计算圆的面积：");
        Observable.range(0, 10)
                  .map(value -> {
                      //针对输出格式的说明：如果形式是#.##，则保留两位小数，但是如果小数位低位是0则会不显示，即3.10会显示成3.1
                      //如果形式是#0.00，则同样保留两位小数，但是小数位低位上的0仍然保留，即完整的显示3.10
                      DecimalFormat format = new DecimalFormat("#0.00");
                      String square = format.format(Math.PI *(value * value));
                      return "半径为 " + value + " 的圆面积是: " + square;
                  }).subscribe(s -> System.out.println(s));
        
        System.out.println();
        
        Observable.just(8,9,10,11)
        .flatMap(value ->{
      //.concatMap(value ->{
            List<String> list = new ArrayList<>();
            for(int i =0;i<3;i++) {
                list.add("this value is " + value);
            }
            Thread.sleep(100);
            return Observable.fromIterable(list);
        }).subscribe(s -> System.out.println(s));
        
        System.out.println();
        Observable.range(0, 20)        
       //.buffer(3).subscribe(s -> System.out.println(s));
       .buffer(3,2).subscribe(s -> System.out.println(s));
    }

    执行结果：

    计算圆的面积：
    半径为 0 的圆面积是: 0.00
    半径为 1 的圆面积是: 3.14
    半径为 2 的圆面积是: 12.57
    半径为 3 的圆面积是: 28.27
    半径为 4 的圆面积是: 50.27
    半径为 5 的圆面积是: 78.54
    半径为 6 的圆面积是: 113.10
    半径为 7 的圆面积是: 153.94
    半径为 8 的圆面积是: 201.06
    半径为 9 的圆面积是: 254.47

    this value is 8
    this value is 8
    this value is 8
    this value is 9
    this value is 9
    this value is 9
    this value is 10
    this value is 10
    this value is 10
    this value is 11
    this value is 11
    this value is 11

    [0, 1, 2]
    [2, 3, 4]
    [4, 5, 6]
    [6, 7, 8]
    [8, 9, 10]
    [10, 11, 12]
    [12, 13, 14]
    [14, 15, 16]
    [16, 17, 18]
    [18, 19]

    代码说明：
     concatMap和flatMap的作用几乎一模一样, 只是它的结果是严格按照上游发送的顺序来发送，
     buffer拥有非常多的重载方法，这里只拿其中的两个来说明：
     bufer(int count):
         该操作符方法会将上游发送的数据切分成多个组，每个组的数量是count个，最后一组有多少就存多少，不足count个时，不会用其他数值进行补充，由此判断每个组切分后的数据没有重复;

     bufer(int count,int offset):
         源码中第二个参数定义的是skip，此处按个人理解，感觉使用offset更好解释.该操作符方法将上游的数据进行切分成多个组，每个组的数量也是count个，最后一组有多少就存多少，
         不足count个时，不会用其他数值进行补充，从第二组开始，数值是前一组对应下标上的数值偏移offset之后的值。该方法要求count是大于0的整数，所以当count小于0,无效操作。