# RxJavaDemo

**Repository Path**: forezp/RxJavaDemo

## Basic Information

- **Project Name**: RxJavaDemo
- **Description**: No description available
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2018-06-28
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# RxJavaDemo
Rxjava在目前的开发中已经是如火如荼，非常的流行，唯一的就是上手不太容易，学习成本高，学习rxjava有一段时间了，也看了[老罗的rxjava视频](http://www.apkbus.com/forum.php?mod=viewthread&tid=257703&extra=page%3D1%26filter%3Dauthor%26orderby%3Ddateline&_dsign=43e9b95f)，决定自己总结下。 

另外欢迎star我的另一个项目,[瓣呀，一个基于豆瓣API模仿网易云音乐的开源app](https://github.com/forezp/banya) 
### 准备
在android工程中的gradle.build中配置，为了更好的理解，所以导入java8 的lambda 表达式。

 ```
compile 'io.reactivex:rxjava:1.2.1'
compile 'io.reactivex:rxandroid:1.2.1'
```
### 基础
 rxjava 中有两个核心的对象Observable（被观察者，它会发出一系列的事件源）和Subscribers（观察者，接受事件源），Observable发出事件后，中间可以有一系列的操作、变化，可以精确的控制事件，最终被观察者所接收。其中Observable每发出一个事件就会，就会调用他的subscriber 的onext()，直到发生错误onerror()或onComplete()结束。

1.用Observable.create去创建一个Observable对象，并发射一个"hi Rxjava"，就结束。

```
Observable<String> observable= Observable.create(
      new Observable.OnSubscribe<String>() {    
   @Override   
   public void call(Subscriber<? super String>    subscriber)
   {  
      subscriber.onNext("hi RxJava");           
      subscriber.onCompleted();   
  }});
```
然后，我们需要去创建一个subscriber去处理observable发射过来的数据。

```
Subscriber<String> subscriber=new Subscriber<String>() {
   @Override  
   public void onCompleted() {     
      Log.e(TAG,"onCompleted"); 
   }   
  @Override  
   public void onError(Throwable e) {                    
      Log.e(TAG,e.getMessage());   
   }    
  @Override
  public void onNext(String s) {     
      Log.e(TAG,s);   
  }};
```
最后需要，subscribe函数把observable对象和subscriber对象关联起来，这样就完成了subscriber对observable的订阅。

```
observable.subscribe(subscriber);
```
程序运行一下：
![运行结果](http://upload-images.jianshu.io/upload_images/2279594-47628cd15faae8fa.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
可能你觉得这样太复杂了，但是涉及到了与之前不一样的变成思想，即响应式编程。

2.用just去创建observable，just英语意思是仅仅的意思，如果只发出一个事件可以用这种方式。另外在创建Subscriber的时候，如果仅仅关心onNext()，这时可以用Action1这个对象。

```
Observable.just("hi Rxjava2").subscribe(new Action1<String>() {    
   @Override 
   public void call(String s) {       
      Log.e(TAG,s);  
  }});
```
运行程序：

![运行结果](http://upload-images.jianshu.io/upload_images/2279594-ea911afc524c4f35.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

3.用from创建observable，这种方式创建，需要传入一个集合，它会一个一个的发射，在subscriber上它会一个一个的接收。

```
String [] strs={"1","2","3","4"};
Observable.from(Arrays.asList(strs))
.subscribe(new Action1<String>() {   
   @Override   
    public void call(String s) {       
        Log.e(TAG,s);    
 }});
```
运行程序：

![运行结果](http://upload-images.jianshu.io/upload_images/2279594-c92425b80e17d822.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

是不是有点像高级for循环－.－  。

4.操作符map，是用在observable和subcriber中间，是为了操作observable发射的数据，操作之后的数据，会被subcriber 接收。rxjava有很多操作符，map操作符是将一个事件转换为另一个事件的。

```
Observable.just("hi rxjava")
.map(new Func1<String, String>() {  
  @Override    
  public String call(String s) {    
    return s+" ,你好rxjava";   
   }})
.subscribe(new Action1<String>() {    
     @Override    
     public void call(String s) {    
        Log.e(TAG,s);   
  }});
```

运行程序：

![运行结果](http://upload-images.jianshu.io/upload_images/2279594-ffb680d3ef2f5347.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

另外,map操作符可以将转换类型，比如string 转int .

```
Observable.just("hi rxjava")
.map(new Func1<String, Integer>() { 
   @Override    
    public Integer call(String s) { 
       return s.hashCode();    
   }})
.subscribe(new Action1<Object>() { 
   @Override  
    public void call(Object s) {    
       Log.e(TAG,s+"");   
 }});
```
5.flatmap操作符
flatMap操作符接收一个Observable的输出作为输入，同时输出另外一个Observable。在flatMap操作符中，我们可以做一系列的事情，然后输出的新的Observable，这个Observable是我们在Subscriber想要接收的。

```
Observable.create(new Observable.OnSubscribe<List<String>>() {    
  @Override   
  public void call(Subscriber<? super List<String>> subscriber) {           
      String [] strs={"1","2","3","4","5","6","7"};           
      subscriber.onNext(Arrays.asList(strs));   
 }})
.flatMap(new Func1<List<String>, Observable<?>>() {    
   @Override 
   public Observable<?> call(List<String> list) {     
      return Observable.from(list);  
   }})
.subscribe(new Action1<Object>() { 
   @Override   
   public void call(Object o) {  
      Log.e(TAG,o.toString());  
  }});
```
首先Observable发出一个list<String> , 然后经过flatmap 将其变成from创建的Observable，这个Observable将list中的元素一个一个的发射，然后，subcriber 中接收。

运行程序：

![运行结果](http://upload-images.jianshu.io/upload_images/2279594-1ab20874bc9d5feb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

6.filter 操作符，对Observable发射的数据进行过滤操作，哪有subcriber接收 ，哪些不接收。

```
Observable.create(new Observable.OnSubscribe<List<String>>() {    
   @Override 
   public void call(Subscriber<? super List<String>> subscriber) {        
      String [] strs={"1","2","3","4","5","6","7"};          
      subscriber.onNext(Arrays.asList(strs));   
   }})
.flatMap(new Func1<List<String>, Observable<?>>() {    
   @Override 
   public Observable<?> call(List<String> list) {   
     return Observable.from(list);  
  }})
.filter(new Func1<Object, Boolean>() {//filter 操作符，去掉“1”;    
   @Override 
   public Boolean call(Object o) {        
     if(o.toString().equals("1"))return false;   
     return true;    
}})
.subscribe(new Action1<Object>() {
  @Override    
  public void call(Object o) {        
    Log.e(TAG,o.toString()); 
 }});
```
运行程序：

![运行结果](http://upload-images.jianshu.io/upload_images/2279594-485551ccdee1c0ca.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

7.take操作符，固定返回数量。take(2)，返回2个结果。

```
Observable.create(new Observable.OnSubscribe<List<String>>() {    
  @Override  
  public void call(Subscriber<? super List<String>> subscriber) {        
    String [] strs={"1","2","3","4","5","6","7"};        
    subscriber.onNext(Arrays.asList(strs));    
 }})
.flatMap(new Func1<List<String>, Observable<?>>() {    
  @Override   
   public Observable<?> call(List<String> list) {  
      return Observable.from(list);  
  }})
.filter(new Func1<Object, Boolean>() {//filter 操作符，去掉“1”;    
   @Override   
   public Boolean call(Object o) {        
     if(o.toString().equals("1"))return false;     
     return true;    
 }})
.take(2)
.subscribe(new Action1<Object>() {//take 操作符，最多输出的数量    
   @Override  
   public void call(Object o) {     
       Log.e(TAG,o.toString());  
  }});
```
运行程序：

![运行结果](http://upload-images.jianshu.io/upload_images/2279594-2f265edfc90d5640.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

rxjava中还有很多操作符，具体见[官网文档](http://reactivex.io/RxJava/javadoc/)和[中文文档](https://mcxiaoke.gitbooks.io/rxdocs/content/)，操作符可以让你对数据流做任何操作。多个操作符配合起来，可以让很复杂的逻辑变得简单，同时，在操作数据的过程中，subcriber并不需要知道中间做了那些操作，只需要知道返回的结果，操作数据也变的简单。

[源码下载](https://github.com/forezp/RxJavaDemo)