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的線程切換以及數據轉換就說完了。