2024年最全RxJava零基础入门(三)(2)，34岁的程序员我不敢去面试了

2401_84545213

于 2024-05-17 03:56:15 发布

阅读量727

点赞数 7

分类专栏：程序员文章标签： android 面试学习

本文链接：https://blog.csdn.net/2401_84545213/article/details/138985328

版权

程序员专栏收录该内容

165 篇文章 0 订阅

订阅专栏

学习分享

在当下这个信息共享的时代，很多资源都可以在网络上找到，只取决于你愿不愿意找或是找的方法对不对了

很多朋友不是没有资料，大多都是有几十上百个G，但是杂乱无章，不知道怎么看从哪看起，甚至是看后就忘

如果大家觉得自己在网上找的资料非常杂乱、不成体系的话，我也分享一套给大家，比较系统，我平常自己也会经常研读。

2021最新上万页的大厂面试真题

七大模块学习资料：如NDK模块开发、Android框架体系架构…

只有系统，有方向的学习，才能在段时间内迅速提高自己的技术。

这份体系学习笔记，适应人群：
第一，学习知识比较碎片化，没有合理的学习路线与进阶方向。
第二，开发几年，不知道如何进阶更进一步，比较迷茫。
第三，到了合适的年纪，后续不知道该如何发展，转型管理，还是加强技术研究。如果你有需要，我这里恰好有为什么，不来领取！说不定能改变你现在的状态呢！
由于文章内容比较多，篇幅不允许，部分未展示内容以截图方式展示。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！


Observable.just(filePath).map(new Func1<String, Bitmap>() {

  @Override

  public Bitmap call(String path) {



       return getBitmapByPath(path);

  }}).subscribe(new Action1<Bitmap>() {

   @Override

  public void call(Bitmap bitmap) {



          //获取到bitmap，显示

}});

例二：对数据进行预处理，最后得到理想型数据。实际开发过程中，从后台接口获取到的数据也许不符合我们想要的，这时候可以在获取过程中对得到的数据进行预处理（结合Retrofit）。


Observable.just("12345678").map(new Func1<String, String>() {

  @Override

  public String call(String s) {

      return s.substring(0,4);//只要前四位

  }})

.subscribe(new Action1<String>() {

  @Override

  public void call(String s) {

      Log.i("mytag",s);

  }});

先说明一下，为了方便理解，所以写的例子都比较简单，不要以为明明可以简单用if-else解决的事，没必要用这种方式去写，当你真正将这些操作符使用到数据处理中去的时候，你就会发现有多方便。

FlatMap : 和Map很像但又有所区别，Map只是转换发射的数据类型，而flatMap可以将原始Observable转换成另一个Observable。还是举例说明吧。假设要打印全国所有学校的名称，可以直接用Map：

为了更清晰一点，先贴一下School类：


public class School {



  private String name;

  private List<Student> studentList;



  public List<Student> getStudentList() {

      return studentList;

  }

  public void setStudentList(List<Student> studentList) {

      this.studentList = studentList;

  }

  public String getName() {

      return name;

  }

  public void setName(String name) {

      this.name = name;

  }

  public static class Student{

      private String name;

      public String getName() {

          return name;

      }

      public void setName(String name) {

          this.name = name;

      }

  }

}

接着用Map打印学校名称：


List<School> schoolList = new ArrayList<>();

Observable.from(schoolList).map(new Func1<School, String>() {

  @Override

  public String call(School school) {

        return school.getName();

  }}).subscribe(new Action1<String>() {

  @Override

  public void call(String schoolName) {

        Log.i("mytag",schoolName);

  }});

再进一步，打印学校所有学生的姓名，先考虑用Map实现，将所有School对象直接转成Student：


Observable.from(schoolList).map(new Func1<School, School.Student>() {

  @Override

  public School.Student call(School school) {

      return school.getStudentList();

  }}).subscribe(new Action1<School.Student>() {

  @Override

  public void call(School.Student student) {



          Log.i("mytag",student.getName());

  }});

看似可行，但事实上，这是一段错误的代码，细心的人就会发现错误的地方


@Override

public School.Student call(School school) {

  return school.getStudentList();  //错误，Student 是一个对象，返回的却是一个list

}

所以用Map是无法实现直接打印学校的所有学生名字的，因为Map是一对一的关系，无法将单一的School对象转变成多个Student。前面说到，FlatMap可以改变原始Observable变成另外一个Observable，如果我们能利用from()操作符把school.getStudentList()变成另外一个Observable问题不就迎刃而解了吗，这时候就该FlatMap上场了，来看看它是怎么实现的：


Observable.from(schoolList).flatMap(new Func1<School, Observable<School.Student>>() {

  @Override

  public Observable<School.Student> call(School school) {



      return Observable.from(school.getStudentList()); //关键，将学生列表以另外一个Observable发射出去



  }}).subscribe(new Action1<School.Student>() {



  @Override

  public void call(School.Student student) {

      Log.i("mytag",student.getName());

  }});

值得注意的是，flatMap并不保证变换后事件的发送顺序，如果要保证其顺序，建议使用concatMap操作符

Map和FlatMap在我看来就像孪生兄弟一样，非常实用，实际开发中也我也经常使用，个人觉得要想上手RxJava，掌握这两个操作符必不可少。

Map 与 flatMap 这两个操作符的共同点在于，他们都是把一个对象转换为另一个对象，但须注意以下这些特点:

1.flatMap 返回的是一个Observable对象，而 map 返回的是一个普通转换后的对象;

2.flatMap 返回的Observable对象并不是直接发送到Subscriber的回调中，而是重新创建一个Observable对象，并激活这个Observable对象，使之开始发送事件；而 map 变换后返回的对象直接发到Subscriber回调中；

3.flatMap 变换后产生的每一个Observable对象发送的事件，最后都汇入同一个Observable，进而发送给Subscriber回调；

4.map返回类型与 flatMap 返回的Observable事件类型，可以与原来的事件类型一样；

5.可以对一个Observable多次使用 map 和 flatMap；

Buffer： 缓存，可以设置缓存大小，缓存满后，以list的方式将数据发送出去；例：


Observable.just(1,2,3).buffer(2).subscribe(new Action1<List<Integer>>() {

  @Override

  public void call(List<Integer> list) {

      Log.i("mytag","size:"+list.size());

  }});

运行打印结果如下：


11-02 20:49:58.370 23392-23392/? I/mytag: size:2

11-02 20:49:58.370 23392-23392/? I/mytag: size:1

在开发当中，个人经常将Buffer和Map一起使用，常发生在从后台取完数据，对一个List中的数据进行预处理后，再用Buffer缓存后一起发送，保证最后数据接收还是一个List，如下：


List<School> schoolList = new ArrayList<>();

Observable.from(schoolList).map(new Func1<School, School>() {

  @Override

  public School call(School school) {

      school.setName("NB大学");  //将所有学校改名

      return school;

  }}).buffer(schoolList.size())  //缓存起来，最后一起发送

.subscribe(new Action1<List<School>>() {

  @Override

  public void call(List<School> schools) {   

}});

**Take：**发射前n项数据，还是用上面的例子，假设不要改所有学校的名称了，就改前四个学校的名称：


Observable.from(schoolList).take(4).map(new Func1<School, School>() {

  @Override

  public School call(School school) {

      school.setName("NB大学");

      return school;

  }}).buffer(4).subscribe(new Action1<List<School>>() {

  @Override

  public void call(List<School> schools) {

  }});

Distinct: 去掉重复的项，比较好理解：


Observable.just(1, 2, 1, 1, 2, 3)

      .distinct()

      .subscribe(new Action1<Integer>() {

          @Override

          public void call(Integer item) {

              System.out.println("Next: " + item);

          }

      });

输出


Next: 1

Next: 2

Next: 3

**Filter：**过滤，通过谓词判断的项才会被发射，例如，发射小于4的数据：


Observable.just(1, 2, 3, 4, 5)

      .filter(new Func1<Integer, Boolean>() {

          @Override

          public Boolean call(Integer item) {

              return( item < 4 );

          }

      }).subscribe(new Action1<Integer>() {

        @Override

        public void call(Integer item) {

              System.out.println("Next: " + item);

    }});

输出：


Next: 1

Next: 2

Next: 3

以下内容摘自http://blog.csdn.net/u012124438/article/details/53730717

zip

Zip通过一个函数将多个Observable发送的事件结合到一起，然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。


Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {

        @Override

        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

            Log.d(TAG, "emitter 1");

            emitter.onNext(1);

            Log.d(TAG, "emitter 2");

            emitter.onNext(2);

            Log.d(TAG, "emitter 3");

            emitter.onNext(3);

            Log.d(TAG, "emitter 4");

            emitter.onNext(4);

            Log.d(TAG, "emit complete1");

            emitter.onComplete();

        }

    });



    Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {

        @Override

        public void subscribe(ObservableEmitter<String> emitter) throws Exception {

            Log.d(TAG, "emitter A");

            emitter.onNext("A");

            Log.d(TAG, "emitter B");

            emitter.onNext("B");

            Log.d(TAG, "emitter C");

            emitter.onNext("C");

            Log.d(TAG, "emitter complete2");

            emitter.onComplete();

        }

    });



    Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {

        @Override

        public String apply(Integer integer, String s) throws Exception {

            return integer + s;

        }

    }).subscribe(new Observer<String>() {

        @Override

        public void onSubscribe(Disposable d) {

            Log.d(TAG, "onSubscribe");

        }



        @Override

        public void onNext(String value) {

            Log.d(TAG, "onNext: " + value);

        }



        @Override

        public void onError(Throwable e) {

            Log.d(TAG, "onError");

        }




# 文末

**不管怎么样，不论是什么样的大小面试，要想不被面试官虐的不要不要的，只有刷爆面试题题做好全面的准备，当然除了这个还需要在平时把自己的基础打扎实，这样不论面试官怎么样一个知识点里往死里凿，你也能应付如流啊**

小编将自己6年以来的**面试经验和学习笔记**都整理成了一个**937页的PDF，**以及我学习进阶过程中看过的一些优质视频教程。

![](https://img-blog.csdnimg.cn/img_convert/adeeae0e1d59ed8b705250470a0a9d4a.webp?x-oss-process=image/format,png)


其实看到身边很多朋友抱怨自己的工资很低，包括笔者也是一样的，其原因是在面试过程中没有给面试官一个很好的答案。所以笔者会持续更新面试过程中遇到的问题，也希望大家和笔者一起进步，一起学习。



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618156601)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

   Log.d(TAG, "onError");

        }




# 文末

**不管怎么样，不论是什么样的大小面试，要想不被面试官虐的不要不要的，只有刷爆面试题题做好全面的准备，当然除了这个还需要在平时把自己的基础打扎实，这样不论面试官怎么样一个知识点里往死里凿，你也能应付如流啊**

小编将自己6年以来的**面试经验和学习笔记**都整理成了一个**937页的PDF，**以及我学习进阶过程中看过的一些优质视频教程。

[外链图片转存中...(img-mDrAAY3j-1715889353138)]


其实看到身边很多朋友抱怨自己的工资很低，包括笔者也是一样的，其原因是在面试过程中没有给面试官一个很好的答案。所以笔者会持续更新面试过程中遇到的问题，也希望大家和笔者一起进步，一起学习。



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618156601)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

2401_84545213

关注

7
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
2024年最全RxJava零基础入门(三)(2)，34岁的程序员我不敢去面试了

所以用Map是无法实现直接打印学校的所有学生名字的，因为Map是一对一的关系，无法将单一的School对象转变成多个Student。2.flatMap 返回的Observable对象并不是直接发送到Subscriber的回调中，而是重新创建一个Observable对象，并激活这个Observable对象，使之开始发送事件；先说明一下，为了方便理解，所以写的例子都比较简单，不要以为明明可以简单用if-else解决的事，没必要用这种方式去写，当你真正将这些操作符使用到数据处理中去的时候，你就会发现有多方便。
复制链接

扫一扫