RxJava学习（二）

 

RxJava 学习（一）

上一篇文章，请移步

上一篇介绍了基本的用法，这一篇我们来看一下RxJava更高级的用法

变换！

之前我们写的代码里，观察者和被观察者操作的是同一个数据类型

我们现在想 输入字符串获取到另外的类型，比如我这里的例子

User对象

<span style="white-space:pre">		</span>Observable.just("a", "b")
                         .subscribeOn(AndroidSchedulers.mainThread())
                         .observeOn(Schedulers.io())
                         .map(new Func1<String, User>() {

                             @Override
                             public User call(String s) {
                                 try {
                                     Thread.sleep(1000);
                                 } catch (InterruptedException e) {
                                     e.printStackTrace();
                                 }
                                 User user = new User();
                                 user.setName(s);

                                 return user;
                             }
                         })
                         .subscribe(new Action1<User>() {
                             @Override
                             public void call(User user) {
                                Log.e("call", user.getName());
                             }
                         });

主要就是通过一个叫map的方法来实现

在map方法中有一个Func1的参数，这个参数就主要实现从String字符串转换到User对象的逻辑

为了掩饰延时效果，我添加了线程睡眠

还有一个更复杂的变换

<span style="white-space:pre">		</span>String[] str = {"abc", "bcd"};
                Observable.from(str)
                        .subscribeOn(AndroidSchedulers.mainThread())
                        .observeOn(Schedulers.io())
                        .flatMap(new Func1<String, Observable<Integer>>() {
                            @Override
                            public Observable<Integer> call(String s) {
                                char[] c = s.toCharArray();
                                Integer[] is = new Integer[c.length];
                                for (int i = 0; i < c.length; i++) {
                                    is[i] = Integer.valueOf(c[i]);
                                }
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                return Observable.from(is);
                            }
                        })
                        .subscribe(new Action1<Integer>() {
                            @Override
                            public void call(Integer c) {
                                Log.e("test", c + "");
                            }
                        });

我这段程序做的是吧字符串数组中的每个字符串的字符对应的ascii码打印出来

用的是flatMap这个方法

map和flatMap的区别就是，map是转换成一个对象，而flatMap是转换成一个Observable对象