RxJava操作符

Map操作符

Map操作符，是将获取到的数据类型进行转换的一个操作符。他可以将具体从网络端或者其他地方获取到的数据，通过自己编写的方法进行转化成任何你需要的数据类型并返回，交给相应的方法去处理。

 Observable.create(new ObservableOnSubscribe<String>() {
           @Override
           public void subscribe(ObservableEmitter<String> e) throws Exception {
               e.onNext("1");
               e.onNext("2");
               e.onNext("3");
           }
       }).map(new Function<String, Integer>() {
           @Override
           public Integer apply(String s) throws Exception {
               return Integer.parseInt(s);
           }
       }).subscribe(new Consumer<Integer>() {
                   @Override
                   public void accept(Integer integer) throws Exception {
                       Log.i("result",integer + "");     
                   }
               });

这里看到，我们在上游的发射器中发射了三个字符串数字，'1'，'2'，'3'。然后通过Map这个操作符将三个数字转化为int类型的数，最后打印出来。

具体应用

我们在进行网络请求的时候，如果后台返回来了一串json字符串，我们可以在Map操作符中定义一个方法，通过Gson或者FastJson将json字符串转化成为相应的数据bean类型，然后返回给下游，之后我们就可以方便的操作这些对象的set、get方法了。

我们先定义一个json字符串来模拟从网络端获取的数据

{
  "name":"Tome",
  "age":"15",
  "sex":"man"
}

然后根据这个json写一个类Perosn

public class Person {

    /**
     * name : Tome
     * age : 15
     * sex : man
     */

    private String name;
    private String age;
    private String sex;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }
}

最后我们使用RxJava的Map操作符来处理这个请求

Observable.create(new ObservableOnSubscribe<String>() {
          @Override
          public void subscribe(ObservableEmitter<String> e) throws Exception {
              e.onNext(json);
          }
      }).map(new Function<String, Person>() {
          @Override
          public Person apply(String s) throws Exception {
              Gson gson = new Gson();

              return gson.fromJson(json, Person.class);
          }
      }).subscribe(new Consumer<Person>() {
          @Override
          public void accept(Person person) throws Exception {
              Log.i("result",person.getName());
              Log.i("result",person.getAge());
              Log.i("result",person.getSex());
          }
      });

我们看到我们在上游用onNext()方法发射了这个json字符串，然后在中间用map方法通过Gson解析将json字符串解析成为我们之前定义的那个Person类，最后在下游接收到这个类型之后log打印出来相应的数据，我们便完成了所有的操作。是不是特别方便？

其实通过这个我们还可以对一个Url图片进行出处理，通过拿到这个图片的Url，将其转换成为Bitmap然后返回，之后我们直接将这个Bitmap set到相应的位置上即可。

flatMap操作符

flatMap操作符是将获取到的一个元素变化成多个元素之后，通过Observable再次发射出去，之后再由下游进行接收处理。

例如我们在从网络端获取到一个json字符串之后，里面有个对象是个集合对象，我们可以先获取到这个对象，之后再将这个集合对象发射出去，从而直接在下游拿到这个对象操作它，达到我们的目的。

说白了，Map操作符他的操作是一对一的操作，一次只能操作一个对象，处理完成之后也是返回一个对象，但是FlatMap操作符却不同，它一次可以操作多个对象，他的对应关系为一对多或者多对多。在FlatMap的内部，其实是还有一个Observable发射器，当我们将数据处理完成只有，再由一个内部的发射器将这些数据发射出去，从而达到我们一对多或者多对多的目的。

这里需要注意，flatMap对于数据的操作和发射并不是顺序的，而是随机处理的，所以你发射出去的数据可能经过flatMap之后数据的顺序会发生改变，如果我们不想让数据顺序发生改变，我们可以使用concatMap操作符

filter操作符

顾名思义，过滤操作符。我们可以将获取到的数据进行一次条件过滤，从而获取到我们想要的数据

Observable.just(1,2,3,4,5,6,7)
               .filter(new Predicate<Integer>() {
                   @Override
                   public boolean test(Integer integer) throws Exception {

                       return integer > 5 ;
                   }
               })
               .subscribe(new Consumer<Integer>() {
                   @Override
                   public void accept(Integer integer) throws Exception {
                       Log.i("result:",integer + "");
                   }
               });

上面我们将小于5的数据进行了过滤，从而获取到了6，7这两个数字。

interval

轮询操作符。我们可以通过这个操作符来指定一段时间进行轮询操作。我们可以用来他写一个倒计时的计数器。

privat int time = 60;

Observable.create(new ObservableOnSubscribe<Integer>() {
           @Override
           public void subscribe(ObservableEmitter<Integer> e) throws Exception {
               if (time > 0){
                   e.onNext(time -- );
               }else {
                   e.onComplete();
               }
           }
       }).interval(1,TimeUnit.SECONDS)
               .subscribe(new Consumer<Long>() {
                   @Override
                   public void accept(Long aLong) throws Exception {

                   }
               });

我们在这里写一个定时器，规定每隔一秒钟发射一个数据，并且这个变量每次发射完成之后都自减一，一旦减到零，便停止发射。

Map操作符

flatMap操作符

filter操作符

interval

猜你喜欢