RxAndroid/RxJava之初識RxAndroid簡單方法示例

RxJava ?

RxJava

主要的作用就是鍊式完成異步操作,并且非常強大，RxJava最核心的兩個東西是

Observables

（被觀察者，事件源）和

Subscribers

（訂閱者）。

Observables

發出一系列事件，

Subscribers

處理這些事件。

RxAndroid?

RxAndroid

主要的作用也是異步，随意定制主線程、子線程的操作，鍊式程式設計，讓我們的代碼可讀性大大增強，總之，是非常好用。

我們在開始之前肯定還是要先導包的

第一種方式：如果你是用

android studio

可以直接在

build.gradle

中添加依賴

compile ‘io.reactivex:rxandroid:1.2.1’

compile ‘io.reactivex:rxjava:1.1.6’

第二種方式：如果你的網絡不好，或者公司要求開發用禁網，那麼請直接下載下傳

jar

包放在

libs

目錄中，看下

jar

包位置，順便看看目錄結構（本文中用的jar包版本不是最新的，忽略）

先來看下我們的一個需求以及實作這個需求我們用

Rxjava

是怎麼來書寫的

怎麼樣，上面這樣看起來是不是很爽，一目了然地感覺，一眼就知道都執行了什麼方法，對于一些大的項目，難以維護的項目，這樣的方式程式設計，就算以後需要維護，我想比起以前的

if

、

for

嵌套要好很多吧

好了，廢話不多說，看主要代碼

package wlj.com.rxandroid;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import rx.Observable;
import rx.Subscriber;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.schedulers.Schedulers;


/**
 * rxandroid 練習
 * rxjava 練習
 *
 * @author wlj
 * @date 2016/8/5
 */
public class MainActivity extends AppCompatActivity {

    private String TAG = "MainActivity";
    String[] names = {"111", "222", "333"};
    String[][] arrs = {{"11", "12"}, {"21", "22"}, {"31", "32"}};
    String[] nums = {"1", "2", "3", "3", "4", "6"};

    /**
     * @param savedInstanceState
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
//        ObservableCreate();
//        ObservableSimple();
//        ObservableJust();
//        ObservableRange();
//        ObservableThread();
//        ObservableMap();
//        ObservableFrom();
//        ObservableFlatMap();
//        ObservableFilter();
//        ObservableTake();
        ObservableTest();
    }

    /**
     * rxandroid 練習
     * 需求：
     * 1 給出任意一組數字字元串數組
     * 2 去的重複的數字
     * 3 得到大于1的數字
     * 4 隻保留前三位
     * 5 運作在子線程中
     * 6 進行輸出
     */
    private void ObservableTest() {
        Observable.from(nums)
                .map(new Func1<String, Integer>() {
                    @Override
                    public Integer call(String s) {
                        return Integer.parseInt(s);
                    }
                })
                .distinct()
                .filter(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                        return integer > ;
                    }
                })
                .take()
                .observeOn(Schedulers.newThread())
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d(TAG, " 目前數字為：" + integer);
                    }
                });
    }


    /**
     * take 截取前面幾個元素
     */
    private void ObservableTake() {
        Observable.just(, , , , , ).take().subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "目前數字為：" + integer);
            }
        });
    }

    /**
     * filter 過濾我們不想要的值
     */
    private void ObservableFilter() {
        Observable
                .just(, , , , , , , , )
                .filter(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                        return integer > ;
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d(TAG, "目前數字為：" + integer);
                    }
                });
    }

    /**
     * 周遊雙列的集合數組方式
     */
    private void ObservableFlatMap() {
        Action1<String> action1 = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, s);
            }
        };
        Observable
                .from(arrs)
                .flatMap(new Func1<String[], Observable<String>>() {
                    @Override
                    public Observable<String> call(String[] strings) {
                        return Observable.from(strings);
                    }
                })
                .subscribe(action1);
    }

 /**
   * 引用
   */
    private void ObservableFrom() {
        Observable
                .from(names)
                .map(new Func1<String, String>() {
                    @Override
                    public String call(String s) {
                        return "我是：" + s;
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.d(TAG, s);
                    }
                });
    }

    private void ObservableMap() {
        Action1<String> action1 = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, s);
                Log.d(TAG, Thread.currentThread().getName());
            }
        };
        Observable
                .just(, , , , )
                .map(new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        return integer.toString();
                    }
                })
                .observeOn(Schedulers.newThread())
                .subscribe(action1);
    }

    /**
     * 排程的使用
     */
    private void ObservableThread() {
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.d(TAG, "你被調用了 ：" + Thread.currentThread().getName());
                subscriber.onNext("你被調用了1");
            }
        });
        Action1 action1 = new Action1() {
            @Override
            public void call(Object o) {
                Log.d(TAG, "主人有什麼吩咐：" + Thread.currentThread().getName());
            }
        };
        observable
                .observeOn(Schedulers.newThread())
                .subscribe(action1);
    }

    private void ObservableRange() {
        Observable.range(, ).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "call :" + integer);
            }
        });
    }

    private void ObservableJust() {
        Observable.just(, , ).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "call : " + integer);
            }
        });
    }

    /**
     * 簡單用法
     */
    private void ObservableSimple() {
        Observable<String> mObservable = Observable.just("主人下午好");
        mObservable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, s);
            }
        });
    }

    /**
     * 複雜用法
     */
    private void ObservableCreate() {
        //建立一個觀察者
        final Subscriber<String> mSubscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable throwable) {

            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, s);
            }
        };
        //建立被觀察者

        Observable<String> mObservable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                mSubscriber.onNext("下午好");
            }
        });
        //被觀察者綁定觀察者
        mObservable.subscribe(mSubscriber);
    }
}

           

最後列出一些簡單的方法屬性

observables

被觀察者（事件源）

subscribers

觀察者

schedulers

子線程、主線程切換的排程 器，

schedulers.newThread()

在子線程中執行，

schedulers.mainThread()

在主線程中執行，還有

io()

,

computation()

,

immediate()

map

用來操作

observable

和最終的

subscriber

之間修改observable發出事件的類型，比如發出類型為

int

類型，最終為

String

類型，中間用

map

來轉換

from

能夠達到周遊數組的效果，将數組中的元素依次顯示

filter

得到大于或者小于某個數的值

take

得到前幾位值

takelast

得到後幾位值

deitinct

對一個值隻處理一次

當然還有很多，在我們業務需求用到的時候，直接查詢然後再項目中使用即可。

ps 如果覺得對你有用，不妨點贊頂一下，謝謝對我創作的支援