RXJava

1、merge操作符，合併觀察對象

    @Test
    public void testMerge() {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        list1.add("1");
        list1.add("2");
        list1.add("3");

        list2.add("a");
        list2.add("b");
        list2.add("c");

        Observable observable1 = Observable.from(list1);
        Observable observable2 = Observable.from(list2);

        //合併數據  先發送observable2的全部數據，然後發送 observable1的全部數據
        Observable observable = Observable.merge(observable2, observable1);

        observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "rx-- " + o);
            }
        });

    }

2、zip 操作符，合併多個觀察對象的數據。並且允許 Func2（）函數重新發送合併後的數據

    @Test
    public void testZip() {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        list1.add("1");
        list1.add("2");
        list1.add("3");

        list2.add("a");
        list2.add("b");
        list2.add("c");
        list2.add("d");

        Observable observable1 = Observable.from(list1);
        Observable observable2 = Observable.from(list2);

        Observable observable3 = Observable.zip(observable1, observable2, new Func2<String, String, String>() {
            @Override
            public String call(String s1, String s2) {
                return s1 + s2;
            }
        });

        observable3.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "zip-- " + o);
            }
        });
    }

3、scan累加器操作符的使用

    @Test
    public void testScan() {
        Observable observable = Observable.just(1, 2, 3, 4, 5);
        observable.scan(new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer o, Integer o2) {
                return o + o2;
            }
        }).subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "scan-- " + o);
            }
        });

    }

4、filter 過濾操作符的使用

    @Test
    public void testFilter() {
        Observable observable = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable.filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer o) {
                //數據大於4的時候纔會被髮送
                return o > 4;
            }
        }).subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("lxm", "filter-- " + o);
            }
        });
    }

5、 消息數量過濾操作符的使用

// take ：取前n個數據
// takeLast：取後n個數據
// first 只發送第一個數據
// last 只發送最後一個數據
// skip() 跳過前n個數據發送後面的數據
// skipLast() 跳過最後n個數據，發送前面的數據

    @Test
    public void testTake() {
        //take 發送前3個數據
        Observable observable = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable.take(3)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("take-- " + o);
                        Log.i("lxm", "take-- " + o);
                    }
                });

        //takeLast 發送最後三個數據
        Observable observable2 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable2.takeLast(3)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("takeLast-- " + o);
                        Log.i("lxm", "takeLast-- " + o);
                    }
                });

        //first 只發送第一個數據
        Observable observable3 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable3.first()
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("first-- " + o);
                        Log.i("lxm", "first-- " + o);
                    }
                });

        //last 只發送最後一個數據
        Observable observable4 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable4.last()
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("last-- " + o);
                        Log.i("lxm", "last-- " + o);
                    }
                });

        //skip() 跳過前2個數據發送後面的數據
        Observable observable5 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable5.skip(2)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("skip-- " + o);
                        Log.i("lxm", "skip-- " + o);
                    }
                });

        //skipLast() 跳過最後兩個數據，發送前面的數據
        Observable observable6 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable6.skipLast(2)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("skipLast-- " + o);
                        Log.i("lxm", "skipLast-- " + o);
                    }
                });
    }

6、elementAt 、elementAtOrDefault

    @Test
    public void testElement() {
        //elementAt() 發送數據序列中第n個數據 ，序列號從0開始
        //如果該序號大於數據序列中的最大序列號，則會拋出異常，程序崩潰
        //所以在用elementAt操作符的時候，要注意判斷髮送的數據序列號是否越界

        Observable observable7 = Observable.just(1, 2, 3, 4, 5, 6, 7);
        observable7.elementAt(3)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("elementAt-- " + o);
                        Log.i("lxm", "elementAt-- " + o);
                    }
                });

        //elementAtOrDefault( int n , Object default ) 發送數據序列中第n個數據 ，序列號從0開始。
        //如果序列中沒有該序列號，則發送默認值
        Observable observable9 = Observable.just(1, 2, 3, 4, 5);
        observable9.elementAtOrDefault(0, 666)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("elementAtOrDefault-- " + o);
                        Log.i("lxm", "elementAtOrDefault-- " + o);
                    }
                });
    }

7、startWith() 插入數據

    @Test
    public void testStartWith() {
//插入普通數據
//startWith 數據序列的開頭插入一條指定的項 , 最多插入9條數據
        Observable observable = Observable.just("aa", "bb", "cc");
        observable
                .startWith("11", "22")
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("startWith-- " + o);
                        Log.i("lxm", "startWith-- " + o);
                    }
                });

//插入Observable對象
        List<String> list = new ArrayList<>();
        list.add("ww");
        list.add("tt");
        observable.startWith(Observable.from(list))
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        System.out.println("startWith2 -- " + o);
                        Log.i("lxm", "startWith2-- " + o);
                    }
                });
    }

8. delay操作符，延遲數據發送

    @Test
    public void testDelay() {
        Observable<String> observable = Observable.just("1", "2", "3", "4", "5", "6", "7", "8");

        //延遲數據發射的時間，僅僅延時一次，也就是發射第一個數據前延時。發射後面的數據不延時
        observable.delay(3, TimeUnit.SECONDS)  //延遲3秒鐘
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        Log.i("lxm", "delay-- " + o);
                    }
                });

        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

7.定時器

    @Test
    public void testTimer() {
        //5秒後輸出 hello world , 然後顯示一張圖片
        Observable.timer(5, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        System.out.println("timer--hello world " + aLong);
                        Log.i("lxm", "timer ---" + aLong);
                    }
                });
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

8.testInterval

    @Test
    public void testInterval() {

        //參數一：延遲時間  參數二：間隔時間  參數三：時間顆粒度
        Observable observable = Observable.interval(3000, 3000, TimeUnit.MILLISECONDS);
        Subscription subscription = observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println("interval-  " + o);
                Log.i("lxm", "interval");
            }
        });
    }

9、doOnNext() 操作符，在每次 OnNext() 方法被調用前執行

    @Test
    public void testDoNext() {
        Observable observable = Observable.just("1", "2", "3", "4");
        observable.doOnNext(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println("doOnNext--緩存數據" + o);
                Log.i("lxm", "doOnNext--緩存數據" + o);
            }
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
                Log.i("lxm", "onCompleted--");
            }

            @Override
            public void onError(Throwable e) {
                Log.i("lxm", "onError--");
            }

            @Override
            public void onNext(Object o) {
                System.out.println("onNext--" + o);
                Log.i("lxm", "onNext--" + o);
            }
        });
    }

10、Buffer 操作符

//
// Buffer( int n ) 把n個數據打成一個list包，然後再次發送。
// Buffer( int n , int skip) 把n個數據打成一個list包，然後跳過第skip個數據。
// 使用場景：一個按鈕每點擊3次，彈出一個toast

    @Test
    public void testBuffer() {
        List<String> list = new ArrayList<>();
        for (int i = 1; i < 10; i++) {
            list.add("" + i);
        }

        Observable<String> observable = Observable.from(list);
        observable
                .buffer(2)   //把每兩個數據爲一組打成一個包，然後發送
                .subscribe(new Action1<List<String>>() {
                    @Override
                    public void call(List<String> strings) {
                        System.out.println("buffer---------------");
                        Log.i("lxm", "buffer.....");
                        Observable.from(strings).subscribe(new Action1<String>() {
                            @Override
                            public void call(String s) {
                                System.out.println("buffer data --" + s);
                                Log.i("lxm", "buffer data --" + s);
                            }
                        });
                    }
                });
    }

11、throttleFirst 操作符

// 在一段時間內，只取第一個事件，然後其他事件都丟棄。
// 使用場景：1、button按鈕防抖操作，防連續點擊 2、百度關鍵詞聯想，在一段時間內只聯想一次，防止頻繁請求服務器
// 這段代碼，是循環發送數據，每秒發送一個。throttleFirst( 3 , TimeUnit.SECONDS ) 在3秒內只取第一個事件，其他的事件丟棄。

    @Test
    public void testThrottleFirst() {

        Observable.interval(1, TimeUnit.SECONDS)
                .throttleFirst(3, TimeUnit.SECONDS)
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        System.out.println("throttleFirst--" + aLong);
                        Log.i("lxm", "throttleFirst --" + aLong);
                    }
                });

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

14、distinct 過濾重複的數據

    @Test
    public void testDistinct() {

        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("1");
        list.add("3");
        list.add("4");
        list.add("2");
        list.add("1");
        list.add("1");

        Observable.from(list)
                .distinct()
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.println("distinct--" + s);
                        Log.i("lxm", "distinct --" + s);
                    }
                });
    }

15. distinctUntilChanged() 過濾連續重複的數據

    @Test
    public void testDistinctUntilChanged() {

        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("1");
        list.add("3");
        list.add("4");
        list.add("4");
        list.add("2");
        list.add("1");
        list.add("1");

        Observable.from(list)
                .distinctUntilChanged()
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.println("distinctUntilChanged--" + s);
                        Log.i("lxm", "distinctUntilChanged --" + s);
                    }
                });
    }

16.DoOnSubscribe()

    @Test
    public void testDoOnSubscribe() {
//        doOnSubscribe()
//        使用場景： 可以在事件發出之前做一些初始化的工作，比如彈出進度條等等
//        注意：
//        1、doOnSubscribe() 默認運行在事件產生的線程裏面，然而事件產生的線程一般都會運行在 io 線程裏。那麼這個時候做一些，更新UI的操作，是線程不安全的。
//
//        所以如果事件產生的線程是io線程，但是我們又要在doOnSubscribe() 更新UI ， 這時候就需要線程切換。
//
//        2、如果在 doOnSubscribe() 之後有 subscribeOn() 的話，它將執行在離它最近的 subscribeOn() 所指定的線程。
//
//        3、 subscribeOn() 事件產生的線程 ； observeOn() : 事件消費的線程

        Observable.just("1111", "2222", "3333").create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.i("lxm", ".....");
            }
        }).doOnSubscribe(new Action0() {
            @Override
            public void call() {
                Log.i("lxm", "call");
            }
        }).subscribeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread()) // 指定主線程
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i("lxm", "xxxxx = " + s);
                    }
                });
    }

17.Range

    @Test
    public void testRange() {
        Observable.range(10, 20)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i("lxm", "" + integer);
                    }
                });
    }

18.map

@Test
    public void testMap() {

        List<Course> courses = new ArrayList<>();
        courses.add(new Course("course111", "000000001"));
        courses.add(new Course("course222", "000000002"));
        courses.add(new Course("course333", "000000003"));
        courses.add(new Course("course444", "000000004"));
        Student[] students = {new Student("1111", "0001", 20, courses),
                new Student("2222", "0002", 21, courses),
                new Student("3333", "0003", 22, courses),
                new Student("4444", "0004", 23, courses)};

        Observable.from(students)
                .map(new Func1<Student, List<Course>>() {
                    @Override
                    public List<Course> call(Student student) {
                        Log.i("lxm", "student=" + student.getName());
                        return student.getCourse();
                    }
                })
                //被觀察者處於新io線程
//                .subscribeOn(Schedulers.io())
                //觀察者處於主線程
//                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<Course>>() {
                    @Override
                    public void call(List<Course> courses) {
                        Log.i("lxm", "course size = " + courses.size());
                        for (int i = 0; i < courses.size(); i++) {
                            Log.i("lxm", "觀察者:" + courses.get(i).getCourseId() + ":" + courses.get(i).getCourseName());
                        }
                    }
                });
    }

19.flatMap

    @Test
    public void testFlatMap() {

        List<Course> courses = new ArrayList<>();
        courses.add(new Course("course111", "000000001"));
        courses.add(new Course("course222", "000000002"));
        courses.add(new Course("course333", "000000003"));
        courses.add(new Course("course444", "000000004"));
        Student[] students = {new Student("1111", "0001", 20, courses),
                new Student("2222", "0002", 21, courses),
                new Student("3333", "0003", 22, courses),
                new Student("4444", "0004", 23, courses)};

        Observable.from(students)
                .flatMap(new Func1<Student, Observable<Course>>() {
                    @Override
                    public Observable<Course> call(Student student) {
                        return Observable.from(student.getCourse());
                    }
                })
                .subscribe(new Action1<Course>() {
                    @Override
                    public void call(Course course) {
                        Log.i("lxm", "course = " + course.getCourseName());
                    }
                });
    }