RXjava

JxAndroid

让复杂的程序逻辑回归简单 清晰，不用再考虑什么同步 异步的事情

observable(被观察者) Subscriber(订阅者)

- Observable可以是一个网络请求，Subscriber来显示请求结果;

- Observable可以是一个数据库查询，Subscriber来显示查询结果；

- Observable可以是按钮点击事件，Subscriber来响应点击事件；

- Observable可以是大图片文件的加载解析, Subscriber来展示解析后的图片。

* RxJava 的四个基本概念：

- 观察者设计模式

- Observable (可观察者/被观察者)

- subscribe (订阅)

- Event (事件)

RXjava操作符

* 操作符(Operators)(常用的)

- map 转换对象

- flatMap 平铺对象

- filter 过滤

- distinct() 去重复(独特的)

- take(int i) 从开始取出固定个数

- doOnNext 输出元素之前的额外操作(不常用)

- toList() 打包对象为集合

* 调度器(Scheduler), 用于线程控制

- Schedulers.immediate() 默认线程

- Schedulers.newThread() 每次都创建新的线程执行

- Schedulers.io() 包含线程池的机制, 线程个数无限, 可以复用空闲线程(常用)

- Schedulers.computation() CPU密集计算线程, 线程池线程数和CPU数一致.处理图形运算

- AndroidSchedulers.mainThread() Android更新界面的UI主线程(常用)

1.创建被观察者Observable

2.创建观察者Subscriber

3.二者管理.subscribe

4.释放资源

//创建被观察者，导包一定要小心,不要导成java包

//参数是一个对象，泛型代表了要发送的数据类型

Observable.create(new Observable.OnSubscribe<String>(){

});

//创建观察者

new Subscriber<String>(){

onNext();//被观察者发生改变时调用

onError();//方法有异常时回调

onCompleted();//当所有事件观察完毕时，事件结束回调的方法

}

//

.subscribe();

/*RxAndroid所依赖的库*/

compile 'io.reactivex:rxandroid:1.2.1'

compile 'io.reactivex:rxjava:1.1.6'

just与from的区别：

just是对集合中整个数据进行观察

from RxAndroid接收一个集合对象,对其中数据一个一个观察,咱们用数据处理的功能

package com.example.demo_rxjava;

import android.support.v7.app.AppCompatActivity;

import android.os.Bundle;

import android.util.Log;

import java.util.Arrays;

import java.util.List;

import rx.Observable;

import rx.Subscriber;

import rx.functions.Action1;

import rx.functions.Func1;

public class MainActivity extends AppCompatActivity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super .onCreate(savedInstanceState);

setContentView(R.layout. activity_main );

//RXandroid的基本使用,用的是RxAndroid的观察者功能

//rxAndroidBse();

//RxAndroid接收一个集合对象,对其中数据一个一个观察,咱们用数据处理的功能

//rxAndroidFrmo();

//RxAndroid接收一个集合对象,对整个集合进行操作,观察整个集合

//RxAndroidJust();

//RxAndroid接收一个集合对象,对其中数据进行过滤

//RxAndroidFilterStream();

//RxAndroid接收一个集合对象,对其中数据进行转换

//RxAndroidMapStream();

//RxAndroid把拿到的数个集合,进行拆分观察

RxAndroidFlatMap();

}

private void RxAndroidFlatMap() {

List<Integer> integers = Arrays. asList ( 1 , 2 , 3 , 4 , 5 );

List<Integer> integers1 = Arrays. asList ( 6 , 7 , 8 );

List<Integer> integers2 = Arrays. asList ( 9 , 10 );

Observable. just (integers,integers1,integers2)

//参数是集合，把整个集合输出

.flatMap( new Func1<List<Integer>, Observable<?>>() {

//他可以减少双层for循环的使用

@Override

public Observable<?> call(List<Integer> integers) {

return Observable. from (integers);

}

})

.subscribe( new Action1<Object>() {

@Override

public void call(Object o) {

Log. d ( "texts" , "onNext: " +o);

}

});

}

private void RxAndroidMapStream() {

List<Integer> integers = Arrays. asList ( 1 , 2 , 3 , 4 , 5 );

Observable. from (integers)

//对集合的数据进行转换，参数里的泛型 1.代表了转换前的原始数据类型 2.代表了要转换的数据类型

//提示：你可以吧流转换为bitmap,文件 吧string或数据库cursor转换为Bean

.map( new Func1<Integer, String>() {

@Override

public String call(Integer integer) {

return integer.toString();

}

})

.subscribe( new Action1<String>() {

@Override

public void call(String s) {

Log. d ( "texts" , "onNext: " +s);

}

});

}

private void RxAndroidFilterStream() {

List<Integer> integers = Arrays. asList ( 1 , 2 , 3 , 4 , 5 );

//我是要每一个数据进行筛选，所以我们选择from

Observable. from (integers)

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

@Override

public Boolean call(Integer integer) {

return integer % 2 == 0 ;

}

})

.subscribe( new Action1<Integer>() {

@Override

public void call(Integer integer) {

Log. d ( "texts" , "onNext: " +integer);

}

});

}

private void RxAndroidJust() {

List<Integer> integers = Arrays. asList ( 1 , 2 , 3 , 4 , 5 );

//创建被观察者 参数是一个集合 把整个集合一次性输出

Observable. just (integers)

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

@Override

public void call(List<Integer> integers) {

Log. d ( "texts" , "onNext: " +integers);

}

});

}

private void rxAndroidFrmo() {

List<Integer> integers = Arrays. asList ( 1 , 2 , 3 , 4 , 5 );

//创建被观察者 参数是一个集合 使用这种方法，会根据集合的长度，决定调用call的次数

Observable. from (integers)

//创建被观察者，立马就指定了观察者，如此就不用在进行注册绑定了

//如果你用不到onError onCompleted方法 就创建Action1 其中call == onNext方法

.subscribe( new Action1<Integer>() {

@Override

public void call(Integer integer) {

Log. d ( "texts" , "onNext: " +integer);

}

});

}

private void rxAndroidBse() {

//创建被观察者，导包一定要小心,不要导成java包

//参数是一个对象，泛型代表了要发送的数据类型

Observable<String> stringObservable = Observable. create ( new Observable.OnSubscribe<String>() {

@Override

public void call(Subscriber<? super String> subscriber) {

subscriber.onNext( "你好世界" );

}

});

//创建观察者

Subscriber<String> subscriber = new Subscriber<String>() {

@Override

public void onCompleted() { //当所有事件观察完毕时，事件结束回调的方法

Log. d ( "texts" , "onCompleted: " );

}

@Override

public void onError(Throwable e) { //方法有异常时回调

Log. d ( "texts" , "onError: " );

}

@Override

public void onNext(String s) { //被观察者发生改变时调用

Log. d ( "texts" , "onNext: " + s);

}

};

//把观察者注册到被观察者

stringObservable.subscribe(subscriber);

}

}

4.释放资源