RxJava学习；数据转换、线程切换；

时间 2019-11-13

标签 rxjava 学习数据转换线程切换栏目 Java 繁體版

原文原文链接

Observable（被观察者，发射器）发送数据：java

just：发送单个的数据；数据库

Observable.just("cui","chen","bo")
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: "+s);
            }
        });

Log:网络

04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: accept: cui
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: accept: chen
app

04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: accept: boide

fromIterable：发送集合类型的数据；性能

List<String> datas = Arrays.asList("H","W","Rx");
Observable.fromIterable(datas)
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

Log:ui

04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: onNext: H
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: onNext: W
this

04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: onNext: Rxspa

数据转换：线程

map：一对一的转换；

final Integer icon = R.mipmap.ic_launcher_round;
//数据转换
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        e.onNext(icon);
        e.onComplete();
    }
})
        .map(new Function<Integer, Drawable>() {
            @Override
            public Drawable apply(Integer integer) throws Exception {
                return getResources().getDrawable(integer);
            }
        })
        .subscribe(new Observer<Drawable>() {
            @Override
            public void onSubscribe(Disposable d) {
                
            }

            @Override
            public void onNext(Drawable value) {
                ImageView iv = new ImageView(MainActivity.this);
                iv.setImageDrawable(value);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

flatMap：一对多的转换；

public class Course {
    private String name;
    private int id;

    public Course(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

public class Student {
    private String name;

    private ArrayList<Course> courses;

    public Student(String name, ArrayList<Course> courses) {
        this.name = name;
        this.courses = courses;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }
}

Course yuwen = new Course("语文", 1);
Course shuxue = new Course("数学", 2);
Course yingyu = new Course("英文", 3);
Course lishi = new Course("历史", 4);
Course zhengzhi = new Course("政治", 5);
Course xila = new Course("希腊语", 6);

ArrayList<Course> course1 = new ArrayList<>();
course1.add(yuwen);
course1.add(shuxue);
course1.add(yingyu);
course1.add(lishi);
course1.add(zhengzhi);
course1.add(xila);
Student zhangsan = new Student("zhangsan", course1);

Observable.just(zhangsan)
        .flatMap(new Function<Student, ObservableSource<Course>>() {
            @Override
            public ObservableSource<Course> apply(Student student) throws Exception {
                return Observable.fromIterable(student.getCourses());
            }
        })
        .subscribe(new Consumer<Course>() {
            @Override
            public void accept(Course course) throws Exception {
                Log.i(TAG, "accept: "+course.getName());
            }
        });

Log：

04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 语文
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 数学
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 英文
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 历史
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 政治
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 希腊语

线程切换：

默认：

Observable.just("CCB")
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: ---"+s+"--线程--"+Thread.currentThread());
            }
        });

Log：

MainActivity: accept: ---CCB--线程--main （主线程）；

添加subscribeOn(Schedulers.io());后；Log：MainActivity: accept: ---CCB--线程--RxCachedThreadScheduler-1 （子线程）

Observable.just("CCB")
        .subscribeOn(Schedulers.io())
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: ---"+s+"--线程--"+Thread.currentThread());
            }
        });

再添加： .observeOn(AndroidSchedulers.mainThread())后；log：MainActivity: accept: ---CCB--线程--main （主线程）；

Observable.just("CCB")
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: ---"+s+"--线程--"+Thread.currentThread());
            }
        });

这样咱们就能够把一些耗时的操做（加载图片、网络请求）放在子线程，而后更新界面的时候再切换到主线程；各类线程间的切换只须要一行代码就能够搞定，并且链式调用，思路清晰；

* Schedulers.immediate(): 直接在当前线程运行，至关于不指定线程。这是默认的 Scheduler。
* Schedulers.newThread(): 老是启用新线程，并在新线程执行操做。
* Schedulers.io(): I/O 操做（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差很少，区别在于 io() 的内部实现是是用一个无数量上限的线程池，能够重用空闲的线程，所以多数状况下 io() 比 newThread() 更有效率。不要把计算工做放在 io() 中，能够避免建立没必要要的线程。
* Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操做限制性能的操做，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操做放在 computation() 中，不然 I/O 操做的等待时间会浪费 CPU。
* AndroidSchedulers.mainThread(): Android专用,它指定的操做将在 Android 主线程运行。
* 指定线程的方法:
* Observable.subscribeOn():指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫作事件产生的线程
* Observable.observeOn():指定 Subscriber 所运行在的线程。或者叫作事件消费的线程。

OK！Rxjava的线程切换以及数据转换就说完了。