人妻[21p]大胆,xxxxhdteen欧美内射,小太正白袜飞机gv免费网址

創(chuàng)建型

create

create操作符是所有創(chuàng)建型操作符的“根”，也就是說其他創(chuàng)建型操作符最后都是通過create操作符來創(chuàng)建Observable的.

Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                try {
                    if (!subscriber.isUnsubscribed()) {
                        for (int i = 1; i < 5; i++) {
                            subscriber.onNext(i);
                        }
                        subscriber.onCompleted();
                    }
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG,e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext : "+integer);
            }
        });
    }

from

from操作符是把其他類型的對象和數(shù)據(jù)類型轉(zhuǎn)化成Observable

 String[] strs={"aa","bb","cc","dd"};
        Observable.from(strs).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.e(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG,e.getMessage());
            }

            @Override
            public void onNext(String str) {
                Log.e(TAG,"onNext : "+str);
            }
        });

just

just操作符也是把其他類型的對象和數(shù)據(jù)類型轉(zhuǎn)化成Observable，它和from操作符很像，只是方法的參數(shù)有所差別

 Observable.just(1,"a",'b',"%").subscribe(new Subscriber<Serializable>() {
            @Override
            public void onCompleted() {
                Log.e(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG,e.getMessage());
            }

            @Override
            public void onNext(Serializable serializable) {
                Log.e(TAG,"onNext : "+serializable);
            }
        });

defer

defer操作符是直到有訂閱者訂閱時，才通過Observable的工廠方法創(chuàng)建Observable并執(zhí)行，defer操作符能夠保證Observable的狀態(tài)是最新的.

    i=10;
    Observable justObservable = Observable.just(i);
    i=12;
    Observable deferObservable = Observable.defer(new Func0<Observable<Integer>>() {
        @Override
        public Observable<Integer> call() {
            return Observable.just(i);
        }
    });
    i=15;

    justObservable.subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer o) {
            Log.e(TAG,"just i="+o);
        }
    });

    deferObservable.subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer o) {
            Log.e(TAG,"defer i="+o);
        }
    });
    
    
=====>: ----------defer-----------
=====>: just i=10
=====>: defer i=15

timer

timer操作符是隔一段時間產(chǎn)生一個數(shù)字，然后就結(jié)束，可以理解為延遲產(chǎn)生數(shù)字，也可以用來延遲執(zhí)行動作

timer操作符默認(rèn)情況下是運行在一個新線程上的，當(dāng)然你可以通過傳入?yún)?shù)來修改其運行的線程.

 Observable.timer(2,TimeUnit.SECONDS).subscribe(new Action1<Long>() {
        @Override
        public void call(Long aLong) {
            Log.e(TAG,"timer : "+aLong);
        }
    });

interval

interval操作符是每隔一段時間就產(chǎn)生一個數(shù)字，這些數(shù)字從0開始，一次遞增1直至無窮大，也可以通過改變參數(shù)使其在一段時間內(nèi)遞增。默認(rèn)情況下是運行在一個新線程上的，當(dāng)然你可以通過傳入?yún)?shù)來修改其運行的線程.

Observable.interval(2,TimeUnit.SECONDS).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                Log.e(TAG,"interval : "+aLong);
            }
        });

range

range操作符是創(chuàng)建一組在從n開始，個數(shù)為m的連續(xù)數(shù)字，比如range(3,10)，就是創(chuàng)建3、4、5…12的一組數(shù)字

Observable.range(4,5).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"range : "+integer );
            }
        });

repeat

repeat操作符是對某一個Observable，重復(fù)產(chǎn)生多次結(jié)果

和其他操作符一起使用的

//連續(xù)產(chǎn)生兩組(3,4,5)的數(shù)字
        Observable.range(3,3).repeat(2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e(TAG,"onCompleted");
            }

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

            @Override
            public void onNext(Integer i) {
                Log.e(TAG,"repeat : "+i );
            }
        });

變換

buffer

buffer操作符周期性地收集源Observable產(chǎn)生的結(jié)果到列表中，并把這個列表提交給訂閱者，訂閱者處理后，清空buffer列表，同時接收下一次收集的結(jié)果并提交給訂閱者，周而復(fù)始。

一旦源Observable在產(chǎn)生結(jié)果的過程中出現(xiàn)異常，即使buffer已經(jīng)存在收集到的結(jié)果，訂閱者也會馬上收到這個異常，并結(jié)束整個過程。

 final String[] mails = new String[]{"Here is an email!", "Another email!", "Yet another email!"};
    //每隔1秒就隨機發(fā)布一封郵件
    Observable<String> endlessMail = Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            try {
                if (subscriber.isUnsubscribed()) return;
                Random random = new Random();
                while (true) {
                    String mail = mails[random.nextInt(mails.length)];
                    subscriber.onNext(mail);
                    Thread.sleep(1000);
                }
            } catch (Exception ex) {
                subscriber.onError(ex);
            }
        }
    }).subscribeOn(Schedulers.io());
    //把上面產(chǎn)生的郵件內(nèi)容緩存到列表中，并每隔3秒通知訂閱者
    endlessMail.buffer(3, TimeUnit.SECONDS).subscribe(new Action1<List<String>>() {
        @Override
        public void call(List<String> list) {
            Log.e(TAG,String.format("You've got %d new messages!  Here they are!", list.size()));
            for (int i = 0; i < list.size(); i++)
                Log.e(TAG,"**" + list.get(i).toString());
        }
    });

map操作符是把源Observable產(chǎn)生的結(jié)果，通過映射規(guī)則轉(zhuǎn)換成另一個結(jié)果集，并提交給訂閱者進行處理。

 Observable.just(1,2,3,4,5,6).map(new Func1<Integer, Integer>() {
        @Override
        public Integer call(Integer integer) {
            //對源Observable產(chǎn)生的結(jié)果，都統(tǒng)一乘以3處理
            return integer*3;
        }
    }).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            Log.e(TAG,"next:" + integer);
        }
    });

faltMap

flatMap操作符是把Observable產(chǎn)生的結(jié)果轉(zhuǎn)換成多個Observable，然后把這多個Observable“扁平化”成一個Observable，并依次提交產(chǎn)生的結(jié)果給訂閱者。

flatMap操作符通過傳入一個函數(shù)作為參數(shù)轉(zhuǎn)換源Observable，在這個函數(shù)中，你可以自定義轉(zhuǎn)換規(guī)則，最后在這個函數(shù)中返回一個新的Observable，然后flatMap操作符通過合并這些Observable結(jié)果成一個Observable，并依次提交結(jié)果給訂閱者。

flatMap操作符在合并Observable結(jié)果時，有可能存在交叉的情況

contactMap

cancatMap操作符與flatMap操作符類似，都是把Observable產(chǎn)生的結(jié)果轉(zhuǎn)換成多個Observable，然后把這多個Observable“扁平化”成一個Observable，并依次提交產(chǎn)生的結(jié)果給訂閱者。

與flatMap操作符不同的是，concatMap操作符在處理產(chǎn)生的Observable時，采用的是“連接(concat)”的方式，而不是“合并(merge)”的方式，這就能保證產(chǎn)生結(jié)果的順序性，也就是說提交給訂閱者的結(jié)果是按照順序提交的，不會存在交叉的情況。

switchMap

switchMap操作符與flatMap操作符類似，都是把Observable產(chǎn)生的結(jié)果轉(zhuǎn)換成多個Observable，然后把這多個Observable“扁平化”成一個Observable，并依次提交產(chǎn)生的結(jié)果給訂閱者。

與flatMap操作符不同的是，switchMap操作符會保存最新的Observable產(chǎn)生的結(jié)果而舍棄舊的結(jié)果，舉個例子來說，比如源Observable產(chǎn)生A、B、C三個結(jié)果，通過switchMap的自定義映射規(guī)則，映射后應(yīng)該會產(chǎn)生A1、A2、B1、B2、C1、C2，但是在產(chǎn)生B2的同時，C1已經(jīng)產(chǎn)生了，這樣最后的結(jié)果就變成A1、A2、B1、C1、C2，B2被舍棄掉了！

//flatMap操作符的運行結(jié)果
    Observable.just(10, 20, 30).flatMap(new Func1<Integer, Observable<Integer>>() {
        @Override
        public Observable<Integer> call(Integer integer) {
            //10的延遲執(zhí)行時間為200毫秒、20和30的延遲執(zhí)行時間為180毫秒
            int delay = 200;
            if (integer > 10)
                delay = 180;
            return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
        }
    }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            Log.e(TAG,"flatMap Next:" + integer);
        }
    });

    //concatMap操作符的運行結(jié)果
    Observable.just(10, 20, 30).concatMap(new Func1<Integer, Observable<Integer>>() {
        @Override
        public Observable<Integer> call(Integer integer) {
            //10的延遲執(zhí)行時間為200毫秒、20和30的延遲執(zhí)行時間為180毫秒
            int delay = 200;
            if (integer > 10)
                delay = 180;

            return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
        }
    }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            Log.e(TAG,"concatMap Next:" + integer);
        }
    });

    //switchMap操作符的運行結(jié)果
    Observable.just(10, 20, 30).switchMap(new Func1<Integer, Observable<Integer>>() {
        @Override
        public Observable<Integer> call(Integer integer) {
            //10的延遲執(zhí)行時間為200毫秒、20和30的延遲執(zhí)行時間為180毫秒
            int delay = 200;
            if (integer > 10)
                delay = 180;

            return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
        }
    }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            Log.e(TAG,"switchMap Next:" + integer);
        }
    });

結(jié)果

=====>: ------flatMap、concatMap、switchMap-----
=====>: flatMap Next:30
=====>: flatMap Next:20
=====>: flatMap Next:10
=====>: flatMap Next:15
=====>: flatMap Next:10
=====>: flatMap Next:5

=====>: switchMap Next:30
=====>: switchMap Next:15

=====>: concatMap Next:10
=====>: concatMap Next:5
=====>: concatMap Next:20
=====>: concatMap Next:10
=====>: concatMap Next:30
=====>: concatMap Next:15

GroupBy

groupBy操作符是對源Observable產(chǎn)生的結(jié)果進行分組，形成一個類型為GroupedObservable的結(jié)果集，GroupedObservable中存在一個方法為getKey()，可以通過該方法獲取結(jié)果集的Key值（類似于HashMap的key)。

值得注意的是，由于結(jié)果集中的GroupedObservable是把分組結(jié)果緩存起來，如果對每一個GroupedObservable不進行處理（既不訂閱執(zhí)行也不對其進行別的操作符運算），就有可能出現(xiàn)內(nèi)存泄露。因此，如果你對某個GroupedObservable不進行處理，最好是對其使用操作符take(0)處理。

cast

cast操作符類似于map操作符，不同的地方在于map操作符可以通過自定義規(guī)則，把一個值A(chǔ)1變成另一個值A(chǔ)2，A1和A2的類型可以一樣也可以不一樣；而cast操作符主要是做類型轉(zhuǎn)換的，傳入?yún)?shù)為類型class，如果源Observable產(chǎn)生的結(jié)果不能轉(zhuǎn)成指定的class，則會拋出ClassCastException運行時異常。

scan

scan操作符通過遍歷源Observable產(chǎn)生的結(jié)果，依次對每一個結(jié)果項按照指定規(guī)則進行運算，計算后的結(jié)果作為下一個迭代項參數(shù)，每一次迭代項都會把計算結(jié)果輸出給訂閱者。

window

window操作符非常類似于buffer操作符，區(qū)別在于buffer操作符產(chǎn)生的結(jié)果是一個List緩存，而window操作符產(chǎn)生的結(jié)果是一個Observable，訂閱者可以對這個結(jié)果Observable重新進行訂閱處理。

過濾

debounce

distinct
elementAt
filter
ofType
first
single
last
ignoreElements
sample
skip
skipLast
take
takeFirst
takeLast

組合操作符

merge
zip
join
combineLatest
and/when/then
switch
startSwitch

本文為作者學(xué)習(xí)用，內(nèi)容抄自RxJava操作符
更多操作符看RxJava docs

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

Rxjava操作符

Rxjava操作符

創(chuàng)建型

變換

過濾

組合操作符

推薦閱讀更多精彩內(nèi)容

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

Rxjava操作符

創(chuàng)建型

變換

過濾

組合操作符

推薦閱讀更多精彩內(nèi)容

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