rxJava------>看我72变

Ladys 的先生们，看这里。

rxJava虽然没有中国文化那样博大精深，但是其变换还是嘿嘿嘿，非常爽的。

在写变换前，我先写下我对rxjava delay方法的一些认识：

delaySubscription  - - - - - - - - - -> 先delay一段时间，再执行Observable
delay(long delay, TimeUnit unit)  - - - - - - - - - -> Observable执行后，先delay一段时间，再执行Observer
delay(Func1<? super T, ? extends Observable<U>> itemDelay)- - - - - - - - - -> Observable执行后，先执行Func1，再执行Observer

要提到变换 ，那就得用操作符了：

（1）just变化

Observable.just("hello")
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.print("-----收到的信息------>"+s);
                    }
                });

(2) from变换

ArrayList strArray =new ArrayList();
        strArray.add("看我");
        strArray.add("72");
        strArray.add("变!");
        Observable.from(strArray)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.print("-----------" + s);
                    }
                });

(3) map变换

  Map<Integer, String> map1 = new HashMap<>();
        map1.put(1, "bigger-C");
        map1.put(2, "SimppleBoy");

        Observable.just(map1)
                .map(new Func1<Map<Integer, String>, String>() {
                    @Override
                    public String call(Map<Integer, String> hashMap) {
                        Iterator iterator = hashMap.keySet().iterator();
                        String str = "";
                        while (iterator.hasNext()) {
                            str += hashMap.get(iterator.next());
                            if (iterator.hasNext())
                                str += "----love-----";
                        }
                        return str;
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.print("-----------" + s);
                    }
                });

不要问我 bigger-C和simmpleBoy是谁，反正不是我，是一对好基友，哈哈，希望他俩不要看到。

（4）flatMap变换

 Observable.just(map1)
                .flatMap(new Func1<Map<Integer, String>, Observable<String>>() {
                    @Override
                    public Observable<String> call(Map<Integer, String> hashMap) {
                        Iterator iterator = hashMap.keySet().iterator();
                        String str = "";
                        while (iterator.hasNext()) {
                            str += hashMap.get(iterator.next());
                            if (iterator.hasNext())
                                str += "----love-----";
                        }

                        final String finalStr = str;
                        return Observable.create(new Observable.OnSubscribe<String>() {
                            @Override
                            public void call(Subscriber<? super String> subscriber) {
                                subscriber.onNext(finalStr);
                            }
                        });
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.print("-----------" + s);
                    }
                });

是不是棒棒哒。OK，变换还有好多种变换，这里只是简单地介绍下，剩下的给你个眼神，自己去体会好了。
变换主要是对Observerable 、func、Observer、action的操作，就这几个的组合。但是变化却有好多种，再加入其他的retrofit、okhttp等的组合，你就会看到不一样的rxJava了。