大但人文艺术欣赏ppt图片192 ,国产美国日产系列区别,精产一二三产区划分标准图片

Observable的創建操作符

just——直接返回list

       Observable.just(new String[]{"This", "is", "RxJava"})
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String[]>() {
                    @Override
                    public void accept(@NonNull String[] strings) throws Exception {
                        for(String string :strings){
                            Log.i("just",""+strings);
                        }
                    }
                }) ;

fromArray——依次返回list的每個item

        Observable.fromArray(new String[]{"This", "is", "RxJava"})
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable disposable) {
                    }
                    @Override
                    public void onNext(@NonNull String s) {
                    }
                    @Override
                    public void onError(@NonNull Throwable throwable) {
                    }
                    @Override
                    public void onComplete() {

                    }
                });

interval操作符——延時幾秒，每隔幾秒開始執行

Flowable.interval(1, TimeUnit.SECONDS)
Flowable.interval(0, 1, TimeUnit.SECONDS)////參數一：延時0秒；參數二：每隔1秒開始執行

timer——延時之后發射數據項為0的Observable<Long>

Observable.timer(1000, TimeUnit.MILLISECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(@NonNull Long aLong) throws Exception {
                    }
                });

range——創建從n開始，個數為m的連續數字，比如range(3,4)，就是創建3、4、5、6的一組數字

Observable的聚合操作符

reduce—— 發射最終的結果

Observable.just(1,2,3,4).reduce(new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                        return integer+integer2;
                    }
                })
                .subscribe(integer -> Log.d("rxjava",integer.toString()));//10

scan——與reduce很像，對Observable發射的每一項數據應用一個函數，然后按順序依次發射每一個值

    Observable.just(2, 3, 4, 5, 6)
                .scan(new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                        return integer + integer2;
                    }
                })
                .subscribe(integer -> Log.d("rxjava", integer.toString())); //2,5,9,14,20

collect——收集數據到一個可變的數據結構

    Observable.just(1,2,3,4)
                .collect(new Callable<List<Integer>>() { //創建數據結構
                    @Override
                    public List<Integer> call() {
                        return new ArrayList<Integer>();
                    }
                }, new BiConsumer<List<Integer>, Integer>() { //收集器
                    @Override
                    public void accept(@NonNull List<Integer> integers, @NonNull Integer integer) throws Exception {
                        integers.add(integer);
                    }
                })
                .subscribe(new Consumer<List<Integer>>() {
                    @Override
                    public void accept(@NonNull List<Integer> integers) throws Exception {
                    }
                };

Observable的條件操作符

contains

    Observable.just(1,2,3,4)
                .contains(3)
                .subscribe(aBoolean -> Log.d("rxjava",aBoolean.toString())); //true

takeUntil——當發射的數據滿足某個條件（包含該數據）后終止
takeWhile—— 當發射的數據滿足某個條件（不含該數據）后終止

Observable.just(2,3,4,5)
                .takeUntil(new Predicate<Integer>() {
                    @Override
                    public boolean test(@NonNull Integer integer) throws Exception {
                        return integer==4;
                    }
                }).subscribe(integer -> Log.d("rxjava",integer.toString())); //2,3,4

sequenceEqual—— 判斷兩個Observable發射的數據是否相同（數據，發射順序）

Observable.sequenceEqual(Observable.just(2,3,4,5),Observable.just(2,3,4,5)) .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(@NonNull Boolean aBoolean) throws Exception {

            }
        });

Observable的過濾操作符

filter——過濾數據

                   .filter(new Predicate<String>() {
                           @Override
                           public boolean test(String s) throws Exception {
                               //true為繼續執行下去，false攔截
                               return s.trim().length() > 0;
                           }
                       })

take——只發射開始的N項數據或者一定時間內的數據

Observable.just(1,2,3,4)
                .take(3)//發射前三個數據項
                .take(100, TimeUnit.MILLISECONDS)//發射100ms內的數據
                .takeLast(3) //只發射最后的N項數據或者一定時間內的數據

first——只發射第一項（或者滿足某個條件的第一項）數據
distinct——過濾重復數據

   Observable.just(1,2,3,4,3,5,3).distinct().subscribe(item->Log.d("rxjava",item.toString())); //1,2,3,4,5

distinctUntilChanged——過濾掉連續重復的數據

 Observable.just(1,2,3,4,5,3,3).distinctUntilChanged().subscribe(item->Log.d("rxjava",item.toString())); //1,2,3,4,5,3

ofType——過濾指定類型的數據

Observable.just(1,2,"3").ofType(Integer.class).subscribe(item -> Log.d("rxjava",item.toString()));

skip——跳過開始的N項數據或者一定時間內的數據

Observable.just(2,3,4,5)
                .skip(1)
                .subscribe(integer -> Log.d("rxjava",integer.toString()));//3,4,5

Observable的組合操作符

concat——按順序連接多個Observables。Observable.concat(a,b)等價于a.concatWith(b)。

     Observable<Integer> observable1=Observable.just(1,2,3,4);
     Observable<Integer>  observable2=Observable.just(4,5,6);
     Observable.concat(observable1,observable2).subscribe(item->Log.d("rxjava",item.toString()));//1,2,3,4,4,5,6

startWith——在數據序列的開頭增加一項數據。startWith的內部也是調用了concat

 Observable.just(1,2,3,4,5)
    .startWith(6,7,8)
    .subscribe(item->Log.d("JG",item.toString()));//6,7,8,1,2,3,4,5

merge——按照時間線來連接
zip——以最少的Observable為標準進行壓合

        Observable<Integer>  observable1=Observable.just(1,2,3,4);
        Observable<Integer>  observable2=Observable.just(4,5,6);
        Observable.zip(observable1, observable2, new BiFunction<Integer, Integer,String>() {
            @Override
            public String apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                return integer+"and"+integer2; //1and4,2and5,3and6
            }
        });

Observable的轉換操作符(toList，toMap)

map——類型轉換

           .map(new Function<String, String>() {
              @Override
              public String apply(@NonNull String s) throws Exception {
                return s.toUpperCase();//轉成大寫字母
              }
            })
            .toList() //轉成List
            .map(new Function<List<String>, List<String>>() {
              @Override
              public List<String> apply(@NonNull List<String> strings) throws Exception {
                Collections.reverse(strings);
                return strings;
              }
            })

** flatmap**——把Observable產生的結果轉換成多個Observable，然后把這多個Observable“扁平化”成一個Observable，并依次提交產生的結果給訂閱者
http://blog.csdn.net/qq_35064774/article/details/53057359
switchMap——與flatMap操作符不同的是，switchMap操作符會保存最新的Observable產生的結果而舍棄舊的結果
buffer——定期收集Observable的數據放進一個數據包裹，然后發射這些數據包裹，而不是一次發射一個值

               Observable.range(1, 5)
                .buffer(2)//一次訂閱2個(int count)
              //.buffer(5, 1)//每次剔除一個(int count, int skip)
              //.buffer(2, TimeUnit.SECONDS)//每隔2秒取出消息(long timespan, TimeUnit unit)
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }
                    @Override
                    public void onNext(List<Integer> integers) {
                    //當buffer(2)：    依次輸出[1, 2] 、[3, 4] 、 [5]
                    //當buffer(5, 1)： 依次輸出[1,2,3,4,5]、[2,3,4,5]、[3,4,5][4,5]、[5]
                    //當buffer(2, TimeUnit.SECONDS)：[1,2,3,4,5]
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onComplete() {
                    }
                });

toSortedList—— 收集原始Observable發射的所有數據到一個有序列表，然后返回這個列表。

    Observable.just(6,2,3,4,5)
                .toSortedList(new Comparator<Integer>() {
                    @Override
                    public int compare(Integer integer, Integer t1) {//自定義排序
                        return integer-t1; //>0 升序 ，<0 降序
                    }
                })
                .subscribe(new Consumer<List<Integer>>() {
                    @Override
                    public void accept(@NonNull List<Integer> integers) throws Exception {
                        Log.i("rxjava", integers.toString()); //[2,3,4,5,6]
                    }
                });

cast——在發射之前強制將Observable發射的所有數據轉換為指定類型
debounce——延時多少秒后執行

其他工具集

delay

 .delay(1, TimeUnit.SECONDS)

doOnCompleted——注冊一個動作，對正常完成的Observable使用
doOnTerminate——注冊一個動作，對完成的Observable使用，無論是否發生錯誤
timestamp——加上時間戳

   Observable.just(3, 4, 5, 6).timestamp().subscribe(new Consumer<Timed<Integer>>() {
            @Override
            public void accept(@NonNull Timed<Integer> integerTimed) throws Exception {
                Log.i("rxjava","time="+integerTimed.time()+",value="+integerTimed.value());
                //  Log.i("rxjava","time=1500357633032,value=3);
            }
        }) ;

感謝：
http://blog.csdn.net/maplejaw_/article/details/52396175

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Rxjava基本操作符使用方法

Rxjava基本操作符使用方法

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Rxjava基本操作符使用方法

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频