rxjava操作符

最新推荐文章于 2021-03-07 15:40:26 发布

原创最新推荐文章于 2021-03-07 15:40:26 发布 · 258 阅读

0 ·

CC 4.0 BY-SA版权

rxjava 专栏收录该内容

52 篇文章

订阅专栏

本文详细介绍了RxJava中常用的操作符，包括map、flatMap、concatMap等转换操作符，以及timer、interval等时间相关操作符。同时，还探讨了filter、distinct等过滤操作符的应用场景，并展示了如何利用RxJava进行UI事件处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考： Rxjava操作符汇总

示例一：

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;

import com.example.administrator.rxjava2netdemo.R;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableTransformer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.schedulers.Schedulers;

/**
 * ================================================
 * 作    者：marsxq
 * 创建日期：2018/4/3
 * 描    述：
 * ================================================
 */
public class MyActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        //map:一对一转换
        Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onNext(4);
        }).map(integer -> "This is result " + integer + "\n")
                .subscribe(str -> System.out.println("accept1====== " + str));

        //flatMap：一对多转换，但不能保证事件的顺序
        Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
        }).flatMap(integer -> {
            List<String> list = new ArrayList<>();
            for (int i = 0; i < 3; i++) {
                list.add("I am value " + integer + "\n");
            }
            return Observable.fromIterable(list).delay(1000, TimeUnit.MILLISECONDS);
        }).subscribe(s -> System.out.println("accept2====== " + s));


        //concatMap：一对多转换，可以保证事件的顺序
        Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
        }).concatMap(integer -> {
            final List<String> list = new ArrayList<>();
            for (int i = 0; i < 3; i++) {
                list.add("I am value " + integer + "\n");
            }
            return Observable.fromIterable(list).delay(1000, TimeUnit.MILLISECONDS);
        }).subscribe(s -> System.out.println("accept3======" + s));

        //compose：Observable内部转换
        Observable.just(1, 2, 3, 4, 5, 6)
                .compose(applyObservableAsync())
                .subscribe(strings -> System.out.println("accept4====== " + strings));

    }

    //把子线程和主线程进行了一个封装，然后返回了一个ObservableTransformer对象
    private static <T> ObservableTransformer<T, T> applyObservableAsync() {
        return upstream -> upstream.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }
}

打印结果：

accept1====== This is result 1
accept1====== This is result 2
accept1====== This is result 3
accept1====== This is result 4

accept4====== 1
accept4====== 2
accept4====== 3
accept4====== 4
accept4====== 5
accept4====== 6

accept2====== I am value 1
accept2====== I am value 1
accept2====== I am value 1
accept2====== I am value 2
accept2====== I am value 2
accept2====== I am value 2
accept2====== I am value 3
accept2====== I am value 3
accept2====== I am value 3

accept3======I am value 1
accept3======I am value 1
accept3======I am value 1
accept3======I am value 2
accept3======I am value 2
accept3======I am value 2
accept3======I am value 3
accept3======I am value 3
accept3======I am value 3

示例二：

//timer：定时操作，x秒后执行y操作
Observable.timer(2, TimeUnit.SECONDS).subscribe(
        x -> System.out.println("timer======" + x));

//interval:周期性操作，每隔xx秒后执行yy操作
Observable.interval(2, TimeUnit.SECONDS).subscribe(
        x -> System.out.println("interval======" + x));

//merge：合并，并行无序
Observable<Integer> observable1 = Observable.just(1, 2, 3);
Observable<Integer> observable2 = Observable.just(4, 5, 6);
Observable.merge(observable1, observable2)
        .subscribe(x -> System.out.println("merge======" + x));

//concat:合并，（串行有序）没有发射完前一个它一定不会发送后一个。
Observable<Integer> observable3 = Observable.just(1, 2, 3);
Observable<Integer> observable4 = Observable.just(4, 5, 6);
Observable.concat(observable3, observable4)
        .subscribe(x -> System.out.println("concat======" + x));

//zip:组合
Observable<Integer> observable5 = Observable.just(1, 2, 3);
Observable<String> observable6 = Observable.just("a", "b", "c");
Observable.zip(observable5, observable6, (integer, s) -> integer + s)
        .subscribe(x1 -> System.out.println("zip======" + x1));
//1a 2b 3c

//concatEager:并行且有序
Observable<Integer> observable7 = Observable.just(1, 2, 3);
Observable<String> observable8 = Observable.just("a", "b", "c");
Observable.concatEager(Observable.fromArray(observable7, observable8))
        .subscribe(x -> System.out.println("concatEager======" + x));

打印结果：

merge======1
merge======2
merge======3
merge======4
merge======5
merge======6

concat======1
concat======2
concat======3
concat======4
concat======5
concat======6

zip======1a
zip======2b
zip======3c

concatEager======1
concatEager======2
concatEager======3
concatEager======a
concatEager======b
concatEager======c

timer======0

interval======0
interval======1
interval======2
...

示例三：

//filter：过滤。只有满足规则的结果才会提交到观察者手中。
Observable.just(1, 2, 3)
        .filter(integer -> integer < 3)
        .subscribe(x -> System.out.println("filter======" + x));

//distinct:去重。它只允许还没有发射的数据项通过。发射过的数据项直接pass。
Observable.just(1, 2, 3, 4, 2,
        3, 5, 6, 1, 3)
        .distinct()
        .subscribe(x -> System.out.println("distinct======" + x));

//buffer:每次缓存n个再发送
Observable.just(1, 2, 3, 4, 5, 6)
        .buffer(2)
        .subscribe(strings -> {
            for (Integer integer : strings) {
                System.out.println("buffer======" + integer);
            }
            System.out.println("======buffer======");
        });

//skip:忽略掉几项
Observable.just(1, 2, 3, 4, 5, 6)
        .skip(2)
        .subscribe(x -> System.out.println("skip======" + x));

//take：只要几项
Observable.just(1, 2, 3, 4, 5, 6)
        .take(3)
        .subscribe(x -> System.out.println("take======" + x));

打印如下：

filter======1
filter======2

distinct======1
distinct======2
distinct======3
distinct======4
distinct======5
distinct======6

buffer======1
buffer======2
======buffer======
buffer======3
buffer======4
======buffer======
buffer======5
buffer======6
======buffer======


skip======3
skip======4
skip======5
skip======6

take======1
take======2
take======3

RXbinding的使用:允许你以RxJava的形式来处理UI事件

    compile 'com.jakewharton.rxbinding2:rxbinding:2.1.1'
    compile 'com.jakewharton.rxbinding2:rxbinding-support-v4:2.1.1'
    compile 'com.jakewharton.rxbinding2:rxbinding-appcompat-v7:2.1.1'

防止按钮重复点击

RxView.clicks(findViewById(R.id.btn1))
            .throttleFirst(1, TimeUnit.SECONDS)
            .subscribe(new Observer<Object>() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("======onSubscribe======");
                }
        
                @Override
                public void onNext(Object object) {
                    System.out.println("======onNext======" + object); 
                    //一秒之后才可再次打印
                }
        
                @Override
                public void onError(Throwable e) {
                    System.out.println("======onError======");
                }
        
                @Override
                public void onComplete() {
                    System.out.println("======onComplete======");
                }
            });

打印：

04-03 10:18:50.153 ======onSubscribe======
04-03 10:18:52.407 ======onNext======INSTANCE
04-03 10:18:53.544 ======onNext======INSTANCE
04-03 10:18:54.673 ======onNext======INSTANCE
04-03 10:18:55.693 ======onNext======INSTANCE

可见，最少隔一秒才打印。

遍历数组：

String[] names = {"Tom", "Lily", "Alisa", "Sheldon", "Bill"};
Observable.fromArray(names)
        .subscribe(s -> System.out.println("遍历数组======" + s));

打印：

遍历数组======Tom
遍历数组======Lily
遍历数组======Alisa
遍历数组======Sheldon
遍历数组======Bill