Android-學習筆記-RxJava操作符

1 創建操作

創建操作符 Observable 開頭

just() — 將一個或多個對象轉換成發射這個或這些對象的一個Observable
fromArray(), fromFuture()，fromIterable(), — 將一個數組, 一個Future, 或者一個Iterable轉換成一個Observable
create() — 使用一個函數從頭創建一個Observable
defer() — 只有當訂閱者訂閱才創建Observable；爲每個訂閱創建一個新的Observable。（推遲）
range() — 創建一個發射指定範圍的整數序列的Observable
rangeLong()
interval() —創建一個按照給定的時間間隔發射整數序列的Observable ，默認在computation調度器上執行。（循環發送數據，數據從0開始遞增）
intervalRange(long start, long count, long initialDelay, long period)
timer() —創建一個在給定的延時之後發射單個數據的Observable ，默認在computation調度器上執行。（xx時間後，開始執行操作）
empty() — 創建一個什麼都不做直接通知完成的Observable
error() — 創建一個什麼都不做直接通知錯誤的Observable
never() — 創建一個不發射任何數據的Observable

1.1 java 不支持lambda

   Flowable.just("Ios","Android").subscribe(new Consumer<String>() {
              @Override
              public void accept(String s) throws Exception {
                  System.out.println(s);
              }
          });

1.2 支持lambda

   Flowable.just("Ios","Android").subscribe(System.out::println);

   String[] names = {"aa", "bb", "cc"};
   Observable.fromArray(names)...
   Observable.fromArray("one", "two", "three", "four", "five")...

   List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
   Observable.fromIterable(list)...

   Observable.create(emitter -> {
                    emitter.onNext("0");
                    emitter.onNext("1");
                    emitter.onNext("2");
                    emitter.onComplete();
                }
        ).subscribe(System.out::println, Throwable::printStackTrace);

1.3 支持Kotlin

       Flowable.just("Ios","Android").subscribe(::println)

	   Observable.create<String> { emitter ->
	        emitter.onNext("0")
	        emitter.onNext("1")
	        emitter.onNext("2")
	        emitter.onComplete()
	    }.subscribe(::println, Throwable::printStackTrace)
	   // .subscribe ({ println("numIndex=$it") }, { t -> println(t) })

2 變換操作

map( ) — 對序列的每一項都應用一個函數來變換Observable發射的數據序列。
cast( ) — 在發射之前強制將Observable發射的所有數據轉換爲指定類型，是map的一個特殊版本。
flatMap( ), flatMapIterable( )，concatMap( ) — 將Observable發射的數據集合變換Observables集合，然後將這些Observable發射的數據平坦化的放進一個單獨的Observable。
switchMap( ) — 將Observable發射的數據集合變換爲Observables集合，然後只發射這些Observables最近發射的數據。
RxJava2 轉換操作符之FlatMap()方法
 RxJava2 轉換操作符之ContactMap()和flatMapIterable()
RxJava2 轉換操作符之SwitchMap()
總結：flatMap() 將合併後的結果按次序發射，任務可能交叉
concatMap( ) 嚴格按次序發射
switchMap( ) 1 同一個線程，等同於 concatMap()；2 不同線程中，如果前一個任務，尚未執行結束，就會被後一個任務給取消掉。
詳細：我理解是這樣
1 main Thread :都會發射
2 連續new(>=1) ->main ：只有main會發射 (假設連續的new 前一個都未執行完畢)
3 連續new(>=1)（new結尾）：最後一個new發射 (假設連續的new 前一個都未執行完畢)
scan( ) — 對Observable發射的每一項數據應用一個函數，然後依次發射每次函數後的結果。（accumulator 累加）
groupBy( ) — 將Observable分拆爲Observable集合，將原始Observable發射的數據按Key分組，每一個Observable發射一組不同的數據。
buffer( ) — 它定期從Observable收集數據到一個集合，然後把這些數據集合打包發射，而不是一次發射一個。（緩衝）
buffer(count,skip) Android-Rx操作符-buffer
window( ) — 定期將來自Observable的數據分拆成一些Observable窗口，然後發射這些窗口，而不是每次發射一項。

2.1 scan舉例

        //scan操作符-累加
        Observable.just(1, 2, 3, 4, 5)
	              .scan(new BiFunction<Integer, Integer, Integer>() {
	                    @Override
	                    public Integer apply(Integer sum, Integer itemFromIndex1) {
	                        return sum + itemFromIndex1;
	                    }
	                })
                   .subscribe(System.out::println);

2.2 舉例

       val list = listOf(1, 2, 3, 4)
       Observable.fromIterable(list)
            .flatMap<String> { num ->
	               Observable.just(num)
	                         .map { v->v.toString() }
            }
            .subscribe { s -> println("flatMap accept=$s") }
//    flatMap accept=1
//    flatMap accept=2
//    flatMap accept=3
//    flatMap accept=4

		Observable.fromIterable(list)
            .flatMapIterable(object : Function<Int, Iterable<String>> {
                override fun apply(integer: Int): Iterable<String> {
                    return listOf("a" + integer, "b$integer", "c$integer")
                }
            }).subscribe { s -> println("accept=$s") }
//    accept=a1
//    accept=b1
//    accept=c1
//    accept=a2
//    accept=b2
//    accept=c2
//    accept=a3
//    accept=b3
//    accept=c3
//    accept=a4
//    accept=b4
//    accept=c4

            
        Observable.fromIterable(list)
                .switchMap(object : Function<Int, ObservableSource<String>> {
                    override fun apply(integer: Int): ObservableSource<String> {
                        if(integer == 2){
                            return  Observable.just("integer=" + integer).subscribeOn(Schedulers.newThread())
                        }
                        return Observable.just("integer=" + integer)
                    }
                }).subscribe({ num -> Log.e("Operations", "accept=" + num + Thread.currentThread()?.name) }, { t -> println(t) })

2.3 groupBy舉例

      Observable.range(1, 10)
                .groupBy(integer -> integer % 3)
                .subscribe(result ->
                                result.subscribe(value ->
                                       System.out.println("key:" + result.getKey() + ", value:" + value)
                                )
                );

3 過濾操作

filter() — 過濾數據
take() — 只發射開始的N項數據
takeLast() — 只發射最後的N項數據
takeWhile() — 根據指定條件，發射Observable數據，直到指定的條件不成立。
指定條件爲ture,就發射，一旦爲false,就不再發射
skip() — 跳過開始的N項數據，發送後面的數據
skipLast() — 跳過最後的N項數據，發送前面的數據
skipWhile() — 根據指定條件,丟棄Observable發射的數據，直到指定的條件不成立，它開始發射剩下原始數據。
指定條件爲ture,就丟棄，一旦爲false,就發射
firstElement() — 只發射第一項數據
first(default) — 只發射第一項數據，如果Observable爲空就發射默認值
lastElement() — 只發射最後的一項數據
last(default) — 只發射最後的一項數據，如果Observable爲空就發射默認值
elementAt(index,default) — 發射第N項數據,如果第N項是空就發射默認值
sample( ) or throttleLast( ) — 定期發射Observable最近的數據
throttleFirst( ) — 定期發射Observable發射的第一項數據
throttleWithTimeout( ) or debounce( ) — 只有當Observable在指定的時間後還沒有發射數據時，才發射一個數據。（產生數據間隔時間 >= debounce指定超時時間，才發射該數據，否則不發射）
timeout( ) —如果在一個指定的時間段後還沒發射數據，就發射一個異常。
distinct( ) — 過濾掉重複數據
distinctUntilChanged( ) — 過濾掉連續重複的數據
ofType( ) — 只發射指定類型的數據
ignoreElements( ) — 丟棄所有的正常數據，只發射錯誤或完成通知
ignoreElements操作符忽略所有源Observable產生的結果，只把Observable的onCompleted和onError事件通知給訂閱者。

3.1 debounce舉例

        Observable.create(emitter ->
                    {
                        //產生結果的間隔時間分別爲100、200、300...900毫秒
                        for (int i = 1; i < 10; i++) {
                            emitter.onNext(i);
                            Thread.sleep(i * 100);
                        }
                        emitter.onComplete();
                    }
                ).subscribeOn(Schedulers.newThread())
                        .debounce(400, TimeUnit.MILLISECONDS)  //指定超時時間爲400毫秒
                        .subscribe(
                                (integer -> System.out.println("Next:" + integer)),
                                (e -> System.out.println("Error:" + e.getMessage()) ),
                                () -> System.out.print("complete")
                        );
//--------Next:5
//--------Next:6
//--------Next:7
//--------Next:8
//--------Next:9
//--------complete

3.2 sample舉例

       Observable.create(emitter ->
                    {
                        //前8個數字產生的時間間隔爲1秒，後一個間隔爲3秒
                        for (int i = 1; i < 9; i++) {
                            emitter.onNext(i);
                            Thread.sleep(1000);
                        }
                        Thread.sleep(2000);
                        emitter.onNext(9);
                        emitter.onComplete();
                    }
                ).subscribeOn(Schedulers.newThread())
                        .sample(2200, TimeUnit.MILLISECONDS)  //採樣間隔時間爲2200毫秒
                        .subscribe(
                                (item -> System.out.println("Next:" + item)),
                                (e -> System.out.println("Error:" + e.getMessage()) ),
                                () -> System.out.print("complete")
                        );
//        Next:3
//        Next:5
//        Next:7
//        Next:8
//        complete

圖例指定時間間隔定時採樣
emitter.onComplete() 後下遊不再處理上游事件。

4 組合操作

startWith( ) — 在數據序列的開頭增加一項數據
merge( ) — 將多個Observable合併爲一個
mergeDelayError() — 合併多個Observables，讓沒有錯誤的Observable都完成後再發射錯誤通知
zip( ) — 使用一個函數組合多個Observable發射的數據集合，然後再發射這個結果。
combineLatest( ) — 當兩個Observables中的任何一個發射了一個數據時，通過一個指定的函數組合每個Observable發射的最新數據（一共兩個數據），然後發射這個函數的結果
join( )and groupJoin( ) — 無論何時，如果一個Observable發射了一個數據項，只要在另一個Observable發射的數據項定義的時間窗口內，就將兩個Observable發射的數據合併發射
Android-RxJava操作符-join
switchOnNext( ) — 將一個發射Observables的Observable轉換成另一個Observable，後者發射這些Observables最近發射的數據

4.1 startWith舉例

        //插入普通數據
        //startWith 數據序列的開頭插入一條指定的項
        Observable observable = Observable.just( "aa" , "bb" , "cc" ) ;
        observable
                //.startWith("55")
                .startWithArray("11","22")
                .subscribe(o -> System.out.println("startWith1 -- " + o) ) ;

        //插入Observable對象
        List<String> list = new ArrayList<>() ;
        list.add( "xx" ) ;
        list.add( "yy" ) ;
        observable.startWith(Observable.fromIterable( list ))
                  .subscribe(o -> System.out.println("startWith2 -- " + o)) ;

4.2 merge,zip,combineLatest,join舉例

		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.fromIterable(list1);
        Observable observable2 = Observable.fromIterable(list2);
        
        //merge合併數據  先發送observable2的全部數據，然後發送 observable1的全部數據
        Observable.merge(observable2, observable1)
                .subscribe(System.out::println);
        //abc123
        
        // zip操作符，合併多個觀察對象的數據。然後發送合併後的結果
        Observable.zip(observable1, observable2, new BiFunction<String, String, String>() {
            @Override
            public String apply(String s1, String s2) {
                return s1 + s2;
        }) .subscribe(System.out::println);
     //zip-- 1a
     //zip-- 2b
     //zip-- 3c
                
		//combineLatest 
       Observable.combineLatest(observable1, observable2, new BiFunction<String, String, String>() {
            @Override
            public String apply(String s1, String s2) {
                return s1 + s2;
        }).subscribe(System.out::println);
        //3a
        //3b
        //3c

zuochunsheng

發佈了90 篇原創文章 · 獲贊 22 · 訪問量 11萬+

私信關注

Android-學習筆記-RxJava操作符

1 創建操作

2 變換操作

3 過濾操作

4 組合操作

今天！通義靈碼在北京、成都、杭州三城開講啦

【BI 可視化插件】怎麼做？手把手教你實現

Kotlin-學習筆記-注意事項(三)

Kotlin-Android

Android-RxJava操作符-buffer

js-小程序入門-wxml語法(二)

Android-RxJava-Observable冷熱

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結