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 > 1;
                    }
                })
                .take(3)
                .observeOn(Schedulers.newThread())
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d(TAG, " 当前数字为：" + integer);
                    }
                });
    }


    /**
     * take 截取前面几个元素
     */
    private void ObservableTake() {
        Observable.just(1, 2, 2, 2, 5, 4).take(4).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "当前数字为：" + integer);
            }
        });
    }

    /**
     * filter 过滤我们不想要的值
     */
    private void ObservableFilter() {
        Observable
                .just(0, 1, 2, 3, 3, 4, 6, 7, 100)
                .filter(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                        return integer > 5;
                    }
                })
                .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(0, 1, 2, 3, 4)
                .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(0, 10).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "call :" + integer);
            }
        });
    }

    private void ObservableJust() {
        Observable.just(0, 1, 2).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 如果觉得对你有用，不妨点赞、打赏、顶一下，谢谢对我创作的支持

*** 个人主页：http://www.wanglijun.vip***
*** csdn主页：http://blog.csdn.net/mynamelijun***
*** 简书主页：http://www.jianshu.com/users/b6cc5e05848d/latest_articles***