rxandroid基础知识和运算符,内容来自学习红树林的知识

1.导包:
compile 'io.reactivex:rxandroid:1.2.1'

2.按照步骤1.2.3这样往上看。

package com.example.rxand;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import rx.Observable;
import rx.Subscriber;
import rx.functions.Action1;
import rx.functions.Func1;

public class MainActivity extends AppCompatActivity {

    private String TAG = "MainActivity";
    String[] names = {"hanweiwei","liwei","shaoye"};
    String[][] seat = {{"11","12"},{"21","22"},{"31","32","33"}};
    String[] nums = {"0","1","2","2","3","4","5"};

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        /**
         *       1:大多数人说｛Rxjava真的是太好用了｝的最大原因
         * 变换  2:所谓的变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或者事件序列
         *      3:操作符(Operations)
         *
         *          ->String[] urls = {"url1","url2","url3"};
         *   from   ->Observable.from(urls).subscribe(url ->System.out.printIn(url));
         *
         *
         *          ->操作符用在Observable和最终的Subscriber之间修改Observable发出的事件
         *
         *                              ->简单例子
         *   map    ->map 操作符进阶     ->想要字符串的hash值
         *
         *
         *
         *   FlatMap  ->map是在一个item被发射后，到达map处经过转换编程另一个item，然后
         *
         *
         *
         *
         *           ->已知一个Drawable里面图片id数组
         *    作业    ->在map中用子线程读取图片bitmap，并且把当前线程的名字log输出
         *
         *           ->在观察者里，用主线程把bitmap的宽高和线程的名字log输出
         *
         *
         *                          map是在一个item被发射之后，到达map处经过转换变成另一个item，然后继续往下走
         *
         *                          flapMap是item被发射之后，到达flatMap处经过转换变成一个Observable，然而
         *   map与flatMap的区别      这个ObServable并不会直接被发射出去，而是会立刻被激活，然后把它发射出的每个Item
         *                          都传入流中，再继续走下去。
         *
         *
         *   filter         ->过滤我们观测序列中不想要的值
         *
         *
         *
         *   Take    ->只想取开头或结尾的几个元素
         *
         *
         *   TakLast   ->如果我们想要最后N个元素，我们只需使用 TakeLast()
         *
         *             ->Observable.just(0,1,2,3,4,5).takeLast(3).subscribe(new Action1<Integer>()){
         *                  @Override
         *                  public void call(Integer integer) {
         *                       Log.e(TAG,"当前数字为:"+integer);
         *                  });
         *
         *
         *   distinct  ->如果我们想对一个指定的值仅处理一次该怎么办？我们可以对我们的序列使用 disinct()
         *
         *             ->Observable.just(0,1,2,3,4,5).disinct().subscribe(new Action1<Integer>()){
         *                  @Override
         *                  public void call(Integer integer) {
         *                       Log.e(TAG,"当前数字为:"+integer);
         *                  });
         *
         *                                                                          ->如果在一个可观测序列发射一个不同于之前的一个新值时让我们得到
         *                                                                          通知这时候该怎么做？
         *                                                                          我们猜想一下我们观察的温度传感器，每秒发射的室内温度
         *
         *                                                                          ->21” 21” 21” 21”
         *   distinctUntilChanged  ->我们处于系统资源保护并不想在每次值一样时更新数据     ->每次我们获得一个新值，我们都会更新当前正在显示的温度。
         *                                                                          我们出于系统资源保护并不想在每次值一样时更新数据。
         *                                                                          我们想忽略掉重复的值并且在温度确实改变时才想得到通知。
         *                                                                          dinstinctUntilChanged() 过滤函数能做到这一点。它能较。。
         *                                                                          忽略掉所有的重复并且只发射出新的值。
         *
         *                        ->Observable.just(0,1,2,3,4,5).distinctUntilChanged().subscribe(new Action1<Integer>()){
         *                          @Override
         *                          public void call(Integer integer) {
         *                               Log.e(TAG,"当前数字为:"+integer);
         *                          });
         *
         *
         *                  ->从Obsevable中值发射第一个 元素或者最后一个元素
         *   First和last    ->fistOrDefault(10)
         *                  ->lastOrDefault(10)
         *
         *
         *
         *                      ->如果 skip(2)来创建一个不发射前2个元素而是发射它后面的那些数据的序列
         *
         *   Skip和SkipLast     ->  skip() 和 skiplast() 函数与take()和takeLast()想对应。它们用整数
         *                      N做参数，从本质上来说，它们不让Observable发射前N个或者后N个值。如果我们知道
         *                      一个序列以没有太多用的“可控”元素开头或结尾时我们可以使用它
         *
         *
         *   ElementAt      ->函数仅从一个序列中发射第N个元素然后就完成了
         *
         *
         *
         *
         *                ->轮询程序时非常好用。Obervable然后每隔指定时间就会发射(支持  全部的时间单位：秒，毫秒。天，分等等)
         *
         *
         *   interval      ->Observable.just(0,1,2,3,4).interval(5,TimeUnit.SECONDS).subscribe(new Action1<Long>){
         *                       @Override
         *                          public void call(Long long) {
         *                               Log.e(TAG,"call:"+long);
         *                          });
         *
         *
         *   timer()      ->你需要一个一段时间后才发射的Obervable
         *
         *                ->Observable.timer(3000,TimeUnit.MILLISECONDS)
         *                  .subscribe(new Action1<Long>()){
         *                  @Override
         *                          public void call(Long long) {
         *                               Log.e(TAG,"call:"+long);
         *                          });
         *                  }
         *
         *
         *   sample       ->温度传感器。它每一秒都会发射当前室内的温度。说实话，我们并不认为温度会变化的这门快，
         *                  我们可以使用一个小的发射间隔，在Observable后面加一个sample()，我们将创建一个新的
         *                  可观测序列，它将在一个指定的时间间隔里由Observable发射最近一次的数值
         *
         *                ->Observable.just(0,1,2,3,4,5).map(new Func1<Integer,Integer>()){
         *                      @Override
         *                          public void call(Integer integer) {
         *                               try{
         *                                  Thread.sleep(1000);
         *                               }catch(InterruptedException e){
         *                                  e.printStackTrace();
         *                               }
         *                               return integer;
         *                               }
         *                          }).subscribeOn(Schedulers.newThread()).sample(2,TimeUnit.SECONDS)
         *                          .subscribe(new Action1<Integer>)(){
         *                          @Override
         *                          public void call(Integer integer) {
         *                               Log.e(TAG,"call:"+integer);
         *                               }
         *                          });
         *                }
         *
         *                ->throttleFirst()  (想让它定时发射第一个元素而不是最近的一个元素，我们可以使用)
         *
         *
         *
         *   Timeout      ->如果在指定的时间间隔内Observable不发射值的话，它监听的原始的Observable时就会触发onError()函数
         *
         *                ->Observable.just(0,1,2,3,4,5)
         *                .map(new Func1<Integer,Integer>(){
         *                      @Override
         *                      public void call(Integer integer) {
         *                      try{
         *                      if(integer != 3){
         *                          Thread.sleep(1000);
         *                      }else{
         *                          Thread.sleep(3000);
         *                      }
         *                      }catch(InterruptedException e){
         *                         e.printStackTrace();
         *                      }
         *                      return integer;
         *                      }
         *                })
         *                .timeout(2,TimeUnit.SECONDS).subscribe(new Observer<Integer>(){
         *                      @Override
         *                      public void onCompleted(){
         *                          Log.e(TAG,"call>>>:完成");
         *                      }
         *                      @Override
         *                      public void onError(Throwable e){
         *                          Log.e(TAG,"call>>>:失败");
         *                      }
         *                      @Override
         *                      public void onNext(Integer integer){
         *                          Log.e(TAG,"call:"+integer);
         *                      }
         *                });
         *
         *
         *   Debounce      ->从Obervable发射一次新的数据，debounce() 函数开启一个内部定时器，如果在这个间隔
         *                   内没有新的数据，则新的Observable发射出最后一个数据
         *
         *
         *
         */







    }

    /**
     * 步骤:13
     */
    public void subcribeDinstinctUntilChanged(){
        Observable.just(22,22,23,24).distinctUntilChanged().subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG,"当前温度为:"+integer);//不提示重复数字，但提示改变的数字
            }
        });
    }

    /**
     * 步骤:12
     */
    public void subcribeDistinct(){
        Observable.from(nums).distinct().subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e(TAG,"当前数字为:"+s);//过滤重复数字
            }
        });
    }

    /**
     * 步骤:12
     */
    public void subcribeExercice(){
        Observable.from(nums).map(new Func1<String, Integer>() {
            @Override
            public Integer call(String s) {
                return Integer.parseInt(s);
            }
        }).filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer > 1;
            }
        }).take(3).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG,"当前数字为:"+integer);
            }
        });
    }


    /**
     * 步骤:12
     */
    public void subcribeTack(){
        Observable.just(0,1,2,3,4,5).take(3).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG,"当前数字为:"+integer);
            }
        });
    }

    /**
     * 步骤:11
     */
    public void subcribeFileter(){
        Observable.just(0,1,2,3,4,5).filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer > 1;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG,"当前数字为:"+integer);
            }
        });
    }

    /**
     * 步骤:10
     */
    public void SubscribeFlatMap(){
        //只要String
        Action1<String> action = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e(TAG,"当前座位号:"+s);
            }
        };

        Observable.from(seat).flatMap(new Func1<String[], Observable<String>>() {
            @Override
            public Observable<String> call(String[] strings) {
                return Observable.from(strings);
            }
        }).subscribe(action);


        Observable.from(seat).map(new Func1<String[], String>() {
            @Override
            public String call(String[] strings) {
                return null;
            }
        }).subscribe(action);
    }


    /**
     * 步骤：9  from的操作
     */
    public void SubscribeFrom(){

        //比较笨的方法，还有别的方式
        Observable.just(names[0],names[1],names[2]).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e(TAG,s);
            }
        });

        //这个比较不错。不一定是数组。集合也可以使用
        Observable.from(names).map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return "我叫："+s;
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e(TAG,s);   //一条一条的输出
            }
        });
    }

    /**
     * 步骤：8  Map的操作
     */
    public void SubscribeMap(){
        Action1<String> action1 = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e(TAG,s);
            }
        };
        Observable.just(0,1,2,3,4,5).map(new Func1<Integer, String>() {
            @Override
            public String call(Integer integer) {
                return integer.toString();  //map对数据做了处理。在交出去
            }
        }).subscribe(action1);
        Observable.just("来一桶泡面","来个鸡块","来瓶矿泉水").map(new Func1<String, String>() {
            @Override
            public String call(String integer) {
                return integer+"记得加辣椒";//map对数据做了处理。在交出去，每一个数据都添加了
            }
        }).subscribe(action1);
    }


    /**
     * 步骤：7
     */
    //测试在什么线程中执行    ***********主题：调度器   实现线程控制***********
    /**
     * 在不指定线程的情况下，Rxjava遵循的是线程不变原则，即：在哪个线程中调用了subscribe()，就在那个线程
     * 生产事件，也就是在那个线程消费事件
     */

    /**
     * 如果需要切换线程，就需要Scheduler调度器
     *
     * 相当于线程控制器，Rxjava通过它来指定每一段代码运行什么样的线程，Rxjava已经内置了几个Schedulers，
     * 他们适合大多数场景，都可以从Schedulers类的静态方法获取
     */

    /**
     * Schedulers.immediate() 在当前线程执行
     * Schedulers.newThread()在新线程中执行
     * AndroidSchedulers.mainThread() androidUI线程中执行
     *
     *                              Schedulers,io() i/o操作（读写文件，读写数据库。网络信息交互等）所使用的线程，
     *                              行为模式与newThread(  0 差不多
     *
     * Schedulers.io()              区别在于io()的内部实现是用一个无数量上限的线程池，可以重用空闲的线程，因此多数IO（）
     *                              比newThread()更有效率，不要把计算工作放在IO()中，可以避免创建不必要的线程
     *
     * Schedulers.computation()    计算机所用的线程，这个计算的是CPU密集计算，即不会被I/O等操作限制性能的操作
     *                             *例如图形计算，这个scheduler使用固定的线程池，大小为CPU核数，不要把I/O放在
     *                             computation中
     *                             *否则IO操作的等待时间会浪费CPU
     *
     *
     */
//    Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>(){
//
//        @Override
//        public void call(Subscriber<? super String> subscriber) {
//            Log.e(TAG,"你被调用了" + Thread.currentThread().getName());
//            subscriber.onNext("你被调用了");
//        }
//    });
//    Action1 action1 = new Action1() {
//        @Override
//        public void call(Object o) {
//            Log.e(TAG,"少爷有什么吩咐" + Thread.currentThread().getName());
//        }
//    };
//    observable.observeOn(Schedulers.newThread()).subscribe(action1);//1:你被调用了main  2:少爷有什么吩咐main



    //-------------------------------步骤：6--------清晰度对比，简洁-----------------------------

    /**
     * 需求：给出任意一组数字字符串数组
     * 得到大于1的数字
     * 去掉重复数字
     * 前面三位数字
     * 进行输出
     */
//    String[] num = {"0","1","2","2","3","4","5","6"};
//    List<Integer> data = new ArrayList<Integer>();
//    for (int i = 0; i < num.length; i++){
//        int a = Integer.parseInt(num[i]);
//        if(a > 1){
//            for (int j = 0; j < data.size();j++){
//                if(a != data.get(j)){
//                    data.add(a);
//                    if(data.size() < 4){
//                        Log.e(TAG,"onCreate:" + a);
//                    }
//                }
//            }
//        }
//    }


//    Observable.just("1","2","2","3","4","5")
//            .map(Integer::parseInt)          转换类型
//            .filter(s -> s > 1)              过滤大于1的
//            .distinct()                      过滤重复数据
//            .take(3)                         我只要前面的3个
//            .subscribe(System.out::printIn); 9   输出


//    Observable.just("1","2","2","3","4","5")
//            .subscribeOn(Schedulers.newThread())       子线程
//            .map(Integer::parseInt)
//            .filter(s -> s > 1)
//            .distinct()
//            .take(3)
//            .observeOn(AndroidSchedulers.mainThread()) 主线程
//            .subscribe(System.out::printIn);//9

    /**
     * 步骤：5
     */
    public void obServaJust1(){
        Observable.just(0,1).repeat(5).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG,"call:"+integer);
            }
        });     //情况1:just:0    输入5次。 情况2：just:0,1    0,1  0,1 0,1 0,1 0,1 每个5次
    }

    /**
     * 步骤：4
     */
    public void obServaRange(){
        Observable.range(0,10).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG,"call:"+integer);
            }
        });     //输出了0-9
    }

    /**
     * 步骤：3
     */
    public void obServaJust(){
        Observable.just(0,1,2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG,"call:"+integer);
            }
        });  //输出了0，1，2
    }

    /**
     * 步骤：2
     */
    public void obServaSimple(){
        Observable<String> observable = Observable.just("我要大块的肉");
        observable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e(TAG,s);
            }
        });
    }

    /**
     * 步骤：1
     */
    public void obServaOnCreate(){
        /*观察者*/
        Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.e(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.e(TAG,"onNext:"+s); //得到  去装一大碗米饭
            }
        };

        /*被观察者*/
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("去装一大碗米饭");
                subscriber.onCompleted();
            }
        });
        //绑定
        observable.subscribe(subscriber);


    }
}