RxJava笔记--01

RxJava采用的是观察者模式

警察抓小偷(本示例使用RxJava2.0.1)

1、创建Observer(警察)

Observer即观察者，它决定事件触发后，执行什么样的动作
（偷东西事件触发后，执行抓捕）

2、创建Observable(小偷)

Observable即被观察者，它决定什么时候触发事件、触发什么样的事件(什么时候偷东西，他来决定)

3、Subscribe(订阅)

创建了Observer、Observable之后，再用subscribe()方法将它们连接起来，完成订阅

     //1、创建被观察者(小偷)
     Observable observable = Observable.create(new ObservableOnSubscribe()
        {
            /*
             * 1、小偷被监听的时候，该方法会自动被调用
             *
             * 2、该方法中将警察传递了进来，调用了警察的回调方法
             */
            @Override
            public void subscribe(ObservableEmitter e) throws Exception
            {
                e.onNext("不好啦");
                e.onNext("不好啦");
                e.onNext("月亮掉进井里啦");
                e.onComplete();
            }
        });

        //2、创建观察者(警察)
        Observer<String> observer = new Observer<String>()
        {
            @Override
            public void onSubscribe(Disposable d)
            {
                System.out.println("onSubscribe");
            }

            @Override
            public void onNext(String value)
            {
                System.out.println("onNext" + value);
            }

            @Override
            public void onError(Throwable e)
            {
                System.out.println("onError" + e.getMessage());
            }

            @Override
            public void onComplete()
            {
                System.out.println("onComplete");
            }
        };

//3、注册
observable.subscribeWith(observer);

//输出结果为：
I/System.out: onSubscribe
I/System.out: onNext不好啦
I/System.out: onNext不好啦
I/System.out: onNext月亮掉进井里啦
I/System.out: onComplete

第二种：使用fromArray，将整个数组传递给观察者

        int[] intArr = {1, 2, 3, 4, 5};

        Observable observable = Observable.fromArray(intArr);

        Observer observer = new Observer()
        {
            @Override
            public void onSubscribe(Disposable d)
            {
                System.out.println("onSubscribe");
            }

            @Override
            public void onNext(Object value)
            {
                int[] arr = (int[]) value;
                for (int i = 0; i < arr.length; i++)
                {
                    System.out.println(arr[i]);
                }
            }

            @Override
            public void onError(Throwable e)
            {
                System.out.println("onError");
            }

            @Override
            public void onComplete()
            {
                System.out.println("onComplete");

            }
        };
        observable.subscribeWith(observer);



        /*
        输出结果为：
        I/System.out: onSubscribe
        I/System.out: 1
        I/System.out: 2
        I/System.out: 3
        I/System.out: 4
        I/System.out: 5
        I/System.out: onComplete
         */

第三种：使用just，依次将数组传递给观察者

        Integer[] arr1 = {1,2};
        String[] arr2 = {"呵呵","哈哈"};
        Observable observable = Observable.just(arr1,arr2);


        Observer<Object[]> observer = new Observer<Object[]>()
        {
            @Override
            public void onSubscribe(Disposable d)
            {
                System.out.println("onSubscribe");
            }

            @Override
            public void onNext(Object[] value)
            {
                for (int i = 0; i < value.length; i++)
                {
                    System.out.println(value[i]);
                }
            }

            @Override
            public void onError(Throwable e)
            {
                System.out.println("onError");
            }

            @Override
            public void onComplete()
            {
                System.out.println("onComplete");
            }
        };
        observable.subscribeWith(observer);

        /*
        输出结果如下：

        I/System.out: onSubscribe
        I/System.out: 1
        I/System.out: 2
        I/System.out: 呵呵
        I/System.out: 哈哈
        I/System.out: onComplete
         */