RxAndroid之Action，Func，map，flatmap的简单用法。

继续学习Rx，苦逼苦逼，感觉智商不够用了呢。
主要总结一下Action，Func，map，flatmap的简单用法，以及线程切换的使用。
原理，依然不明。

Action

场景：观察者输出一句被观察者传入的句子
还是萌新的时候，老老实实的用new Subscriber写吧

        Observable.just("我爱你")
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(String s) {

                        Log.i(TAG, s);
                    }
                });

用action之后的写法
二者是等价的
这里的原理”我觉得”是subscribe()自动将Action1里面的call方法转换成了Subscriber的onNext方法。

  Observable.just("我爱你")
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

map和Func

二者放在一起是因为，我感觉他们两个就是一对儿cp。
场景：现在有一个家庭，家庭里面有两个人，我需要在传入家庭，而得到家庭成员
家庭的实体类如下

public class Home {
    List<String> list;

    public Home() {
        list = new ArrayList<>();
        list.add("王元姬");
        list.add("司马昭");
    }

    public List<String> getList() {
        return list;
    }
}

常规写法

 final Home home=new Home();
        Observable.create(new Observable.OnSubscribe<List<String>>() {
            @Override
            public void call(Subscriber<? super List<String>> subscriber) {
                subscriber.onNext(home.getList());
            }
        }).subscribe(new Action1<List<String>>() {
            @Override
            public void call(List<String> strings) {
                for (String s :
                        strings) {
                    Log.i(TAG, s);
                }
            }
        });

上面的写法很容易理解，Observable将家庭成员的集合添加到队列，而后subscriber用一个for循环将list里面的人员打印出来。

map和func的组合写法

Home home=new Home();
        Observable.just(home)
                .map(new Func1<Home, List<String>>() {
                    @Override
                    public List<String> call(Home home) {
                        return home.getList();
                    }
                }).subscribe(new Action1<List<String>>() {
                    @Override
                    public void call(List<String> strings) {
                        for (String s:strings) {
                            Log.i(TAG, s);
                        }
                    }
                });

二者的作用是一样的，可以看到map和func的组合使用，将参数home，改变成了一个list，整个事件的参数，也变成了list。这里称之为变换。
其实我们看到for循环很不爽，对吧，也许会想到，把一开始的just(home)改成from（home.getList()），然后用一个map(new Func1()｛……｝把list变换成String不就好了吗？但是很遗憾，map只能一一变换，也就是说，一个list是不能变换成多个String的。
于是乎，

flatMap的写法

 Home home=new Home();
        Observable.just(home)
                .flatMap(new Func1<Home, Observable<String>>() {
                    @Override
                    public Observable<String> call(Home home) {
                        return Observable.from(home.getList());
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

看起来可能会很晕，但是仔细一想还是很容易理解的
要取得家庭成员里面的名字，从传入参数开始，需要经历几个步骤
传入home＝1＝》取得家庭成员集合＝ 2＝》取得集合的元素
其实也就两步需要变换
map做了什么呢
map在第1步把home变成了集合，但是因为无法做到第2步，所以只能加入一个for循环在subscriber里面处理
既然1步做不到，那我就两步好了！
这个两步就是flatmap

现在来看一下flatpmap的做法

flatMap(new Func1<Home, Observable<String>>()

很眼熟吧，和map一样，其实都是把传入的参数Home，变换成了另外一个类型，当然，这里的类型不再是基本类型，居然是一个新的Observable，而这个Observable是什么样的呢
return Observable.from(home.getList());
这里，恍然大悟，我从原来的Observable里面又创建了一个Observable，由这个Observable来进行后续的事件

总结一下，整个事件经过了以下流程
Observable（1）传入home＝ ＝》faltMap拿到home＝ ＝》生成Observable（2）（醒目！！）＝ ＝》Observable（2）继续执行subscribe
而在变换Observable（2）（醒目！！）这一内部，又发生了home= =》String。
其实聪明如你一定想说，这什么玩意儿，明明可以一句话搞定的：

 Home home=new Home();
        Observable.from(home.getList())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

确实如此，当然复杂的例子我一时半会也想不出来，感觉这样可以解释清楚flatMap的原理。

关于线程切换的简单说明

Observable.create(new Observable.OnSubscribe<Bitmap>() {
            @Override
            public void call(final Subscriber<? super Bitmap> subscriber) {
                OkHttpClient client=new OkHttpClient();
                client.newCall(new Request.Builder().url(PATH3).build())
                        .enqueue(new Callback() {
                            @Override
                            public void onFailure(Call call, IOException e) {

                            }

                            @Override
                            public void onResponse(Call call, Response response) throws IOException {

                                byte[] data=response.body().bytes();
                                Bitmap bitmap=BitmapFactory.decodeByteArray(data,0,data.length);
                                subscriber.onNext(bitmap);
                                subscriber.onCompleted();
                            }
                        });
            }
        }).subscribeOn(Schedulers.io())／／产生subscribe指定在io线程
          .observeOn(AndroidSchedulers.mainThread())／／随后的动作在android主线程
                .subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(Bitmap bitmap) {
                        iMain.show(bitmap);
                    }
                });

抛开OkHttp的部分，这一段代码作的事情，简单来说，就是从网址拿到图片，再把图片加载到activity的imageView中
subscribeOn(Schedulers.io()) 这句话是常用的指定后台获取数据，网络访问通常比较耗时
一旦拿到数据
observeOn(AndroidSchedulers.mainThread()) 切换到主线程，更新UI。
关于subscribeOn和observeOn的具体原理以及区别我还没有弄懂。
以后搞懂了再说吧