RxJava详解(基于2.X版本的变换操作符)

本章节讲述RxJava基于2.X版本的变换操作符

 

 

1.Map()

 

<1> 作用

将被观察者发送的事件转换为任意的类型事件。

 

 

<2> 代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Function;

public class MainActivity extends AppCompatActivity {

    private Disposable disposable;

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

        method();
    }

    /**
     * 创建 RxJava的Map变换符
     */

    public void method() {
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联 发送Int类型的数据
                if (!e.isDisposed()) {
                    e.onNext(1);
                    e.onNext(2);
                    e.onNext(3);
                    e.onComplete();
                }
            }
        }).map(new Function<Object, Object>() {
            @Override
            public Object apply(Object o) throws Exception {
                if (null == o) {
                    return null;
                }

                int num = (int) o;
                Log.d("TAG", "观察者 map转换前数据 结果num----：" + num);

                return "Map变换符操作 " + num + "  后的内容";
            }
        }).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                disposable = d;
                Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != disposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
            if (!disposable.isDisposed()) {//没有断开
                disposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

 

 

<3> 结果

D/TAG: 观察者 onSubscribe方法 是否断开连接：false


D/TAG: 观察者 map转换前数据 结果num----：1

D/TAG: 观察者 onNext方法 结果：Map变换符操作 1  后的内容


D/TAG: 观察者 map转换前数据 结果num----：2

D/TAG: 观察者 onNext方法 结果：Map变换符操作 2  后的内容


D/TAG: 观察者 map转换前数据 结果num----：3

D/TAG: 观察者 onNext方法 结果：Map变换符操作 3  后的内容

 

<4> 关闭页面

D/TAG: onDestroy方法 执行时是否断开----：true

 

 

 

2.FlatMap()

 

<1> 作用

将被观察者发送的事件转换为任意的类型事件。和map类似。只不过它的return方式不同。整体操作成List集合。不保证onNext方法中的顺序和发送的一致。

 

 

<2> 代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import java.util.ArrayList;
import java.util.List;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Function;

public class MainActivity extends AppCompatActivity {

    private Disposable disposable;

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

        method();
    }

    /**
     * 创建 RxJava flatMap变换符
     */

    public void method() {
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联 发送Int类型的数据
                if (!e.isDisposed()) {
                    e.onNext(1);
                    e.onNext(2);
                    e.onNext(3);
                    e.onComplete();
                }
            }
        }).flatMap(new Function<Object, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Object o) throws Exception {
                if (o == null) {
                    return null;
                }

                final List<String> list = new ArrayList<>();
                int num = (int) o;
                list.add("flatMap变换符 " + num + " 后的内容");

                Log.d("TAG", "观察者 flatMap转换前数据 结果num----：" + num);

                return Observable.fromIterable(list);
            }
        }).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                disposable = d;
                Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != disposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
            if (!disposable.isDisposed()) {//没有断开
                disposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

 

 

<3> 结果

D/TAG: 观察者 onSubscribe方法 是否断开连接：false


D/TAG: 观察者 flatMap转换前数据 结果num----：1

D/TAG: 观察者 onNext方法 结果：flatMap变换符 1 后的内容


D/TAG: 观察者 flatMap转换前数据 结果num----：2

D/TAG: 观察者 onNext方法 结果：flatMap变换符 2 后的内容


D/TAG: 观察者 flatMap转换前数据 结果num----：3

D/TAG: 观察者 onNext方法 结果：flatMap变换符 3 后的内容

 

 

<4> 关闭页面

D/TAG: onDestroy方法 执行时是否断开----：false

D/TAG: onDestroy方法 断开订阅

 

 

 

3.ConcatMap()

 

<1> 作用

将被观察者发送的事件转换为任意的类型事件。和flatMap类似。整体操作成List集合。保证onNext方法中的顺序和发送的一致性。

 

 

<2> 代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import java.util.ArrayList;
import java.util.List;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Function;

public class MainActivity extends AppCompatActivity {

    private Disposable disposable;

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

        method();
    }

    /**
     * 创建 RxJava concatMap变换符
     */

    public void method() {
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联 发送Int类型的数据
                if (!e.isDisposed()) {
                    e.onNext(4);
                    e.onNext(5);
                    e.onNext(6);
                    e.onComplete();
                }
            }
        }).concatMap(new Function<Object, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Object o) throws Exception {
                if (o == null) {
                    return null;
                }

                final List<String> list = new ArrayList<>();
                int num = (int) o;
                list.add("concatMap变换符 " + num + " 后的内容");

                Log.d("TAG", "观察者 concatMap转换前数据 结果num----：" + num);

                return Observable.fromIterable(list);
            }
        }).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                disposable = d;
                Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != disposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
            if (!disposable.isDisposed()) {//没有断开
                disposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

 

 

 

<3> 结果

D/TAG: 观察者 onSubscribe方法 是否断开连接：false


D/TAG: 观察者 concatMap转换前数据 结果num----：4

D/TAG: 观察者 onNext方法 结果：concatMap变换符 4 后的内容


D/TAG: 观察者 concatMap转换前数据 结果num----：5

D/TAG: 观察者 onNext方法 结果：concatMap变换符 5 后的内容


D/TAG: 观察者 concatMap转换前数据 结果num----：6

D/TAG: 观察者 onNext方法 结果：concatMap变换符 6 后的内容

 

 

<4> 关闭页面

D/TAG: onDestroy方法 执行时是否断开----：false

D/TAG: onDestroy方法 断开订阅

 

 

 

4.Buffer()

 

<1> 作用

定期从 被观察者（Obervable）需要发送的事件中 获取一定数量的事件 & 放到缓存区中，最终发送。即缓存被观察者发送的事件。

 

 

<2> 代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {

    private Disposable disposable;

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

        method();
    }

    /**
     * 创建 RxJava buffer变换符
     */

    public void method() {
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联 发送Int类型的数据
                if (!e.isDisposed()) {
                    e.onNext(1);
                    e.onNext(2);
                    e.onNext(3);
                    e.onNext(4);
                    e.onNext(5);
                    e.onNext(6);
                    e.onComplete();
                }
            }
        }).buffer(2, 2)
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        if (null == d) {
                            return;
                        }
                        disposable = d;
                        Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
                    }

                    @Override
                    public void onNext(Object value) {
                        Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != disposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
            if (!disposable.isDisposed()) {//没有断开
                disposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

 

public final Observable<List<T>> buffer(int count, int skip) {}

参数1：count：缓存区大小 = 每次从被观察者中获取的事件数量。

参数2：skip：步长 = 每次获取新事件的数量。

 

 

 

<3> 结果

D/TAG: 观察者 onSubscribe方法 是否断开连接：false


D/TAG: 观察者 onNext方法 结果：[1, 2]


D/TAG: 观察者 onNext方法 结果：[3, 4]


D/TAG: 观察者 onNext方法 结果：[5, 6]

 

 

<4> 关闭页面

D/TAG: onDestroy方法 执行时是否断开----：true