【32】RxJava与RxAndroid

RxJava与RxAndroid

1.为什么要学习RxJava与RxAndroid

1.1RxJava能提高工作效率

1.2RxJava能优雅解决复杂业务场景

1.3RxJava使用越来越流行

2.这门课程能够学到什么

2.1了解什么是响应式编程

2.2了解RxJava与RxAndroid到底是什么

2.3了解RxJava的历史来源

它是为了解决什么问题而来的。

2.4清楚RxJava与RxAndroid关系

2.5学会在项目中使用RxJava和RxAndroid

3.相关资源

RxJava文档:https://github.com/ReactiveX/RxJava/wiki
RxJava中文文档:https://mcxiaoke.gitbooks.io/rxdocs/content
RxJava经典资料:https//github.com/lzyzsd/Awesome-RxJava

4.响应式编程概述

4.1什么是响应式编程?

是一种基于异步数据流概念的编程模式.
解说：数据流通俗一点讲它其实就是像我们现实生活中的河流一样，这些河流是可以被我们进行观察的，也可以对这些河流进行过滤，以及可以进行其他各种操作，同时我们也可以把这条河流与另外的河流进行合并，然后组成一条新的河流，总之它其实是一种新的编程模式。

4.2响应式编程关键概念

4.2.1事件

解说： 它其实是软件界于我们生活中的事件，通俗的讲就是把现实生活中的事件搬到软件中的事件。也可以像现实生活中的事件一样，可以对这个事件进行等待，同时这个事件可以触发一个新的过程.
例如学习RxJava,其实可以理解为一件事情，它也可以触发一个学习的过程。同时这个事件也可以触发另外的事件。

4.3响应式编程的使用场景

4.3.1UI(通用)

例如现在手机APP的一个网络请求,还有手机上的一个输入系统，例如系统的一个对话框响应，这些都是响应式编程的使用场景。
也就是把我们现实生活中的这种事件场景发送到我们的软件里面来。

4.3.2微软的响应式扩展编程（函数响应式编程）

微软RX库
即.NET响应式的扩展，即一组我们可以观察的，基于异步的和基于事件的它的一个驱动程序。

5.RxJava概述

5.1RxJava是什么?

5.1.1是一个异步数据处理库

5.1.2是一个扩展的观察者模式

5.2RxJava历史来源

是Netflix公司遇到问题，这个公司不满足于用户量的增长，想找一种什么样的架构来代替他们原来的架构，所以他们借鉴了微软公司提出的响应式编程。
目标：重构当前架构来减少REST调用的次数
尝试：微软RX迁移到JVM

5.3RxJava特点

5.3.1 Jar包<1MB

5.3.2轻量级框架

入侵我们项目不重

5.3.3 支持Java 8 lambda

5.3.4支持Java 6+ & Android2.3 +

5.3.5支持异步和同步

5.4扩展的观察者模式

5.4.1 onCompleted()事件

传统的观察者模式是没有事件结束的通知的，也没有事件错误的通知的模式.
这个方法会在事件结束之后，把通知发送到观察者。

5.4.2onError()事件

把事件错误信息发送给观察者。

5.4.3组合而不是嵌套，避免陷入回调地狱.

6.RxAndroid概述

6.1RxAndroid是什么?

RxAndroid是RxJava针对Android平台的一个扩展，用于Android开发.
针对Android平台提供响应式扩展组件，快速、易于开发Android应用程序。

6.2Schedulers(调度器)

解说：调度器简单说是RxJava可以指定一些相应的操作在某一个线程，比如说在子线程或者是在主线程进行操作。

6.2.1解决Android主线程问题【针对Android】

例如在主线程进行UI操作，可以通过调度器来指定UI的更新，就是在主线程来进行操作，而不是在其他的线程。

6.2.2解决多线程问题

解说：Android的UI操作必须是在主线程，而调度器还可以解决一个多线程的问题.
在做Android开发的时候，涉及到网络请求数据，网络请求数据是一个耗时的操作，Android中耗时的操作都必须放到子线程中来进行一个操作，如果不是放在子线程，那肯定对Android主线程造成卡顿现象。也就是说调度器解决了一个子线程与主线程之间的一个通迅问题。
在Android开发过程中为了解决主线程与子线程的一个通迅问题需要通过Handler，如果使用了RxJava,使用了RxAndroid，这个库就通过调度器来指定我们这些操作是在主线程当中还是在子线程中，即一句代码就可以解决了，就不像平常用Handler写一长串的代码。
例：

	Observable.just(1,2,3,4)//IO线程,由subscribeOn()指定
	.subscribeOn(Schedulers.io())
	.observeOn(Schedulers.newThread())
	.map(mapOperator)//新线程,由observerOn()指定
	.observeOn(Schedulers.io())
	.map(mapOperator2)//IO线程，由observeOn()指定
	.observeOn(AndroidSchedulers.mainThread)
	.subscribe(subscriber);//Android主线程，由obServeOn()指定

7.RxJava与观察者模式

7.1观察者模式的四大要素

7.1.1 Observable被观察者

7.1.2 Observer(观察者)

7.1.3 subscribe(订阅)

解说：订阅的意思是我们的观察者要观察被观察者，

7.1.4 事件

解说：观察者订阅被观察者，遇到被观察者发出事件，观察者就可以接收得到，

7.2观察者模式

观察者订阅被观察者，其中就是订阅它的事件.

7.3 RxJava扩展的观察者模式

onNext()就是订阅的一个事件
onCompleted()
onError()
解说：RxJava扩展的观察者模式多了两个方法，一个是当事件流完成之后，它会回调onCompleted()这个方法，当这些流在流动的过程中如果出现了异常，那么它会回调我们观察者中的onError()方法。

8.总结

8.1RxJava是什么？

其实是一个异步操作的一个库，同时它也是一个支持观察者模式的一个扩展。

8.2RxJava的历史来源

Netflix公司解决当前系统不能适应用户增长量，他们希望借鉴微软响应式编程的模式，来对当前系统进行一个新的架构，RxJava其实就是借鉴微软响应式编程支持Java语言扩展出来的一个库.

8.3RxJava特点

它是一个比较轻量级的一个库，同时jar包比较小，小于1MB,它支持java 8 的lanboda表达式，同时它也支持同步与异步的交互。

8.4RxAndroid的概念

RxAndroid是RxJava在Android平台的一个扩展库，这个主要是针对Android平台开发的一个库。

8.5RxJava的调度器(Schedulers)

主要来解决线程之间的一个通信问题。一句很简单的代码就可以指定具体操作是在子线程还是在主线程。

8.6观察者模式四大要素

被观察者（Observable）、观察者(Observer)、subscribe订阅、事件

观察者与被观察者之间是通过订阅来关联的，关联之间是些什么东西呢？是通过事件来进行驱动的。

8.6RxJava扩展的观察者模式

RxJava是根据观察者模式来进行扩展的，它多了两个回调方法，onCompleted()，onError().

9.RxJava hello world

    package com.gdc.rxjava;
	import rx.Observable;
	import rx.Observable.OnSubscribe;
	import rx.Subscriber;
	
	public class HelloWorld {
	
		public static void main(String[] args) {
			//s1.创建被观察者
			Observable myObservable = Observable.create(new OnSubscribe<String>(){
	
				@Override
				public void call(Subscriber<? super String> subscriber) {
					subscriber.onNext("hello world!!!");
					subscriber.onCompleted();
				}});
			
			//s2.创建观察者
			Subscriber subscriber = new Subscriber<String>(){
	
				@Override
				public void onCompleted() {
					System.out.println("onCompleted()");
				}
	
				@Override
				public void onError(Throwable arg0) {
					System.out.println("onError()");
				}
	
				@Override
				public void onNext(String arg0) {
					System.out.println("onNext():" + arg0);
				}
				
			};
			
			//s3.订阅事件
			myObservable.subscribe(subscriber);
			
		}
	}

onCompleted()与onError()能同时获得调用吗？
onCompleted()与onError()只能回调其中的一个。回调onError()或者onCompleted()方法就代码这个事件已经结束.

10.操作符

10.1操作符的分类

10.1.1 Creating Observables (创建Observable)

10.1.2 Transforming Observables(转换Observable)

10.1.3 Filtering Observables(过滤Observable)

10.1.4 Combining Observables(组合Observable)

10.1.5 Error Handling Operators(处理错误)

很多操作符可以同时组合使用得到我们希望得到的结果。

10.2 Creating Observables (创建Observable)

10.2.1 Create

    private static void create(){
		Observable.create(new OnSubscribe<String>(){

			@Override
			public void call(Subscriber<? super String> subscriber) {
				subscriber.onNext("中华人民共和国 RxJava学习");
			}}).subscribe(new Subscriber<String>() {

				@Override
				public void onCompleted() {
					System.out.println("onCompleted()");
				}

				@Override
				public void onError(Throwable arg0) {
					System.out.println("onError():" + arg0);
				}

				@Override
				public void onNext(String arg0) {
					System.out.println("onNext():" + arg0);
				}
			});
	}

10.2.2 Just

    private static void just() {
		Observable.just("中华人民共和国 RxJava学习").subscribe(new Subscriber<String>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(String arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.2.3 From

转换成各种类型的其他的对象或者数据类型，转换为Observables对象,它可以接收数组与列表.

    private static void from() {
		//1: 数组、
		//2:列表
		//3:Iterable
		//4:Future 
		//5:Future,Scheduler
		//6:Future,timout,timeUnit
		Integer[] a = new Integer[] { 1, 2, 3, 4, 5, 6, 7 };
		//支持2
		ArrayList<Integer> items = new ArrayList<Integer>();
		items.add(1);
		items.add(2);
		items.add(3);
		items.add(4);
		items.add(5);
		items.add(6);
		Observable.from(items).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.2.4 Defer

在我们没有去调用subscribe方法之前不会去创建Observable,直到调用了subscribe()这个方法之后才会创建Observable。
解说：简单理解就是可以延迟的意思。
与前几个操作符create,just,from的区别是，当调用subscribe()才会创建Observable对象。

	
    private static String valuestr;

	private static void defer() {
		//Observable observable = Observable.just(valuestr);
		
		Observable observable = Observable.defer(new Func0<Observable<String>>() {

			@Override
			public Observable<String> call() {
				return Observable.just(valuestr);
			}
		});
		
		valuestr = "中华人民共和国RxJava学习"; 

		observable.subscribe(new Subscriber<String>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(String arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}
	

10.2.5 Empty/Never/Throw

（1）Empty 是创建一个空的，没有任何数据项的一个Observable对象。
如果直接调用则会调用onCompleted()

    private static void empty(){
		Observable.empty().subscribe(new Subscriber() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}			

			@Override
			public void onNext(Object arg0) {
				
				System.out.println("onNext()");
			}
		});
	}

(2)Never
是不进行任何回调观察者的方法

    private static void never(){
		Observable.never().subscribe(new Subscriber() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}			

			@Override
			public void onNext(Object arg0) {
				
				System.out.println("onNext()");
			}
		});
	}

(3)throw
是一个错误的Observable对象，它会回调onError()的方法。

    private static void throwtest() {
		Observable.error(new NullPointerException()).subscribe(new Subscriber() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Object arg0) {

				System.out.println("onNext()");
			}
		});
	}

10.2.6 Interval

解说：即定时器,每间隔一段时间来发射一次，即为一个定时器。

    private static void interval(){
		Observable.interval(1000,TimeUnit.MICROSECONDS).subscribe(new Subscriber() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Object arg0) {

				System.out.println("onNext()");
			}
		});
	}

10.2.7 Range

它是创建一个在一个范围之内的一个整型的一个数据项的Observable对象。

    	private static void range(){
		Observable observable = Observable.range(1, 5);
		observable.subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext()" + arg0);
			}
		});
	}

10.2.8 Repeat

创建一个Observable对象，发射一个特定数据项，即重复发送。

    private static void repeat(){
		Observable observable = Observable.range(1, 5).repeat(2);
		observable.subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext()" + arg0);
			}
		});
	}

10.2.9 Start

创建一个Observable对象，发送开始的数据类型.

####10.2.10 Timer
是一个定时器，每间隔一段时间进行一次发送。

10.3 Transforming Observables(转换Observable)

10.3.1 Map

是将一个对象转换成另外一个我们想转换成的对象。即数据类型的转换。
是一个一对一的转换.返回的是具体的转换的数据类型.

    private static void testTransform() {
		//将整型数据转换成String类型输出
		Observable.just(1,2,3).map(new Func1<Integer, String>() {

			@Override
			public String call(Integer arg0) {
				return arg0 + "";
			}
		}).subscribe(new Subscriber<String>(){

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()" );
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(String arg0) {
				System.out.println("onNext():" + arg0);
			}});
	}

10.3.2 flatMap

是一个一对多的数据转换.它返回的是一个Observable对象，它的里面包含的是我们具体想转换的数据类型。
其实它是把一个对象
转换后返回Observable对象，
然后再把这个Observable对象flat成总的一个Observable对象，然后再将数据发送给观察者。
在Android开发中经常遇到一个网络请求依赖于另一个网络请求，像经常会遇到一个需求，
通过获取到token,然后才根据这个token点击获取数据列表这样的场景。

private static void testFlatMap() {
		
		Observable.just(1, 2, 3,4,5).flatMap(new Func1<Integer, Observable<? extends String>>() {

			@Override
			public Observable<? extends String> call(Integer arg0) {

				return Observable.just(arg0 + "");
			}
		}).subscribe(new Subscriber<String>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(String arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.3.3 GroupBy

分组：它会通过我们指定的规则对数据列表进行一个分组,然后将它发送到观察者这边来。
即可以对数据进行分组。

    private static void testGroupBy(){
		Observable.just(1, 2, 3,4,5).groupBy(new Func1<Integer, Integer>() {

			@Override
			public Integer call(Integer arg0) {
				//分组规则
				return arg0 % 2;
			}
		}).subscribe(new Observer<GroupedObservable<Integer, Integer>>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(GroupedObservable<Integer, Integer> arg0) {

				arg0.subscribe(new Subscriber<Integer>() {

					@Override
					public void onCompleted() {
						
					}

					@Override
					public void onError(Throwable arg0) {
						
					}

					@Override
					public void onNext(Integer data) {
						System.out.println("group:" + arg0.getKey() + " data:" + data);
					}
				});
			}
		});
	}

10.3.4 Buffer

它可以一次性将Observable对象转换成多个数据项，然后将多个数据项发送给观察者。也就是可以将六个数据项，可以订阅3个，一次将3个数据发送给观察者。然后通过观察者打印出来。

//随机生成5个数字，一次性订阅两次，然后打印出来，通过运行得知，只需要3次即可以把数据全部打印出来

	Observable.range(1,5).buffer(2).subscribe(new Subscriber<List<Integer>>() {

		@Override
		public void onCompleted() {
			System.out.println("onCompleted()");
		}

		@Override
		public void onError(Throwable arg0) {
			System.out.println("onError():" + arg0);
		}

		@Override
		public void onNext(List<Integer> arg0) {
			System.out.println("onNext():" + arg0);
		}
	});

10.3.5 Scan

它是通过累加，即有一个序列的数据，它每一次把前面的数据累加，然后发送到观察者。

    private static void testScan() {
		// 1到5的和
		Observable.range(1, 5).scan(new Func2<Integer, Integer, Integer>() {

			@Override
			public Integer call(Integer sum, Integer arg1) {
				// sum:当前数据的和，arg1：每一次需要累加的数据
				return sum + arg1;
			}
		}).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.3.6 Window

它与buffer差不多，Window是返回一个Observable对象，它是必须根据指定的规则然后将数据聚集到一个列表，然后可以通过时间间隔将数据发送给观察者。

10.4 Filtering Observables(过滤Observable)

10.4.1 Debounce

在操作间隔一定的时间内没有做任何操作，那么这个数据才会发送给观察者。
在一个数据项列表中，这个数据项空闲多长时间之后，如果没有发生操作，那么就发送该数据项给观察者。

    private static void testDebounce(){
		Observable.create(new OnSubscribe<Integer>(){

			@Override
			public void call(Subscriber<? super Integer> arg0) {
				try {
					for(int i = 0 ; i < 10; i++){
						Thread.sleep(1000);
						arg0.onNext(i);
					}
					arg0.onCompleted();
				} catch (InterruptedException e) {
					arg0.onError(e);
				}
			}}).debounce(1,TimeUnit.SECONDS).subscribe(new Subscriber<Integer>(){

				@Override
				public void onCompleted() {
					System.out.println("onCompleted()");
				}

				@Override
				public void onError(Throwable arg0) {
					System.out.println("onError():" + arg0);
				}

				@Override
				public void onNext(Integer arg0) {
					System.out.println("onNext():" + arg0);
				}
				
			});
	}

10.4.2 Distinct

这是一个去重的操作符，即去除重复数据的操作符，当数据列表中存在重复数据，需要去除重复数据的情况，就可以使用该操作符。
数据项的某一个操作，当产生1的时候，它有一个时间间隔，然后2、3、4、5它们之间的时间间隔还没有到我们指定的时间，我们一个数据项之后的时间间隔，必须要在我们指定时间内没有发生第二个操作之后，我们才发送数据项到观察者。

    private static void testDistinct(){
		Observable.just(1,2,3,2,3).distinct().subscribe(new Subscriber<Integer>(){

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
			
		});
	}

10.4.3 ElementAt

这个操作符用于取指定位置的数据，这个操作符类似于Java列表List的get方法获取指定位置的数据。

    private static void testElementAt(){
		Observable.just(1,2,3,2,3).elementAt(3).subscribe(new Subscriber<Integer>(){

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
			
		});
	}

10.4.4 Filter

是过滤的意思，这个操作符按照我们指定的一个规则进行条件过滤，得到我们想要的数据，过滤的条件是我们可以自定义的。

    private static void testFilter() {
		Observable.just(1, 2, 3, 2, 3).distinct().filter(new Func1<Integer, Boolean>() {

			@Override
			public Boolean call(Integer arg0) {
				// 在此指定过滤规则
				return arg0 > 2;
			}
		}).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.4.5 First

指的是列表中的第一个数据.

    private static void testFirst() {
		Observable.just(9, 2, 3, 2, 3).distinct().first().subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.4.6 IgnoreElements

意思是忽略掉列表中的所有元素不向观察者发送任何的数据项，只回调我们观察者中的onCompleted()或者是onError()方法。即不会执行onNext()这个方法.

    private static void testIgnoreElements() {
		Observable.create(new OnSubscribe<Integer>() {

			@Override
			public void call(Subscriber<? super Integer> arg0) {
				arg0.onNext(123);
				throw new NullPointerException();
			}
		}).ignoreElements().subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

    private static void testIgnoreElements() {
		Observable.just(123).ignoreElements().subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.4.7 Last

    private static void testLast() {
		Observable.just(9, 2, 3, 2, 3).distinct().last().subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.4.8 Sample

是一个取样，取样操作符，这个操作符让我们可以对数据源进行采集，当我们采集到这个数据之后，才发送到观察者。
Sample操作符类似于一个定时器，是定时的对数据源进行定时的取样，当取样的数据放到列表中，然后一段时间后将取到的数据发送到观察者进行处理。

    private static void testSample() {
		Observable.create(new OnSubscribe<Integer>() {

			@Override
			public void call(Subscriber<? super Integer> arg0) {
				try {
					for (int i = 0; i < 10; i++) {
						Thread.sleep(1000);
						arg0.onNext(i);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).sample(4, TimeUnit.SECONDS).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.4.9 Skip

跳跃列表数据指定数据项。
例如跳过列表的前两项，然后取后面的数据，发送给观察者。

    private static void testSkip() {
		Observable.just(1, 2, 3, 4, 5).skip(2).skipLast(2).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.4.10 SkipLast

跳过数据列表的最后几项，比如跳过列表的后两项数据然后取前面的列表数据，最后将数据发送给观察者。

    private static void testSkip() {
		Observable.just(1, 2, 3, 4, 5).skip(2).skipLast(2).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.4.11 Take

数据列表中有很多个数据项列，只取列有中的前3个数据，那么就是Take(1,3).

    private static void testTake() {
		Observable.just(1, 2, 3, 4, 5).take(2).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.4.12 TakeLast

即取数据项列表中的最后几位数据，可以指定几项数据，如1、2、3、4、5，取后3位数据，即TakeLast(3,5)取的是最后3、4、5条数据.

    private static void testTakeLast() {
		Observable.just(1, 2, 3, 4, 5).takeLast(2).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

过滤型操作符的作用就是寻找出我们想要的数据项，然后再发送给观察者。

10.5 Combining Observables(组合Observable)

10.5.1 Zip

将两个数据源组合成一个数据源之后然后发送给观察者。
1，2，3，4，5
A,B,C,D
组合之后
1A,2B,3C,4D
最终将此结果发送给观察者.

    private static void testZip(){
		Observable<Integer> observable1 = Observable.just(10,20,30);
		Observable<Integer> observable2 = Observable.just(4,8,12,16);
		Observable.zip(observable1,observable2,new Func2<Integer, Integer, Integer>() {

			@Override
			public Integer call(Integer arg0, Integer arg1) {
				return arg0 + arg1;
			}
		}).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.5.2 Merge

两个数据源进行组合，组合之后将组合的数据发送给观察者。组合的数据是无序的，是根据时间的先后顺序进行组合的。
按时间的先后顺序组合成新的数据源发送给观察者。

    private static void testMerge(){
		Observable<Integer> odds = Observable.just(1,3,5);
		Observable<Integer> events = Observable.just(2,4,6);
		Observable.merge(odds,events).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}
		});
	}

10.5.3 StartWith

在一个数据源的最前面进行插入一些数据。

    private static void startWith() {
		Observable<Integer> first = Observable.just(1, 3, 5);
		Observable<Integer> second = Observable.just(2, 4, 6);
		first.startWith(second).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.5.4 CombineLatest

组合两个数据源的数据，然后发送给观察者。按照发送点的最新基数来进行组合，而产生一个新的Observable数据源对象，然后发送给观察者。

    private static void testCombineLatest() {
		Observable<Integer> first = Observable.just(1, 3, 5);
		Observable<Integer> second = Observable.just(2, 4, 6);
		first.combineLatest(first, second, new Func2<Integer, Integer, Integer>() {

			@Override
			public Integer call(Integer arg0, Integer arg1) {
				System.out.println("arg0:" + arg0 + "arg1:" + arg1);
				return arg0 + arg1;
			}
		}).subscribe(new Subscriber<Integer>() {

			@Override
			public void onCompleted() {
				System.out.println("onCompleted()");
			}

			@Override
			public void onError(Throwable arg0) {
				System.out.println("onError():" + arg0);
			}

			@Override
			public void onNext(Integer arg0) {
				System.out.println("onNext():" + arg0);
			}

		});
	}

10.5.5 Join

两个发射对象在一定的间隔之内进行按指定规则结合，然后产生新的数据对象，然后发送给观察者。
类似于数组排列一样，比如前面的是第一个对象是0,1,2,3,第二个元数据对象是a,b,c,就像排列组合一样，在某一个时间点，我们向观察者发送数据的时候，可以与1、2、3进行组合，a,b,c可以与它们进行组合，然后产生一个新的数据对象，之后再向观察者发送数据。

10.5.6 SwitchOnNext

有一个数据源对象，它里面有很多小分支，即有一个大的Observable对象，这个大的Observable对象它产生了很多个小的Observable对象，这个Switch操作符就是要把拥有很多小的Observable数据源对象的对象组合成一个新的数据源对象，然后再发送给观察者。
会有数据覆盖现象产生.

10.6 Error Handling Operators(处理错误)

10.6.1 Catch

捕获异常
操作符方法：
onErrorReturn():
	数据源在某一位置出现异常，当在项目代码中使用onErrorReturn()这个方法，它会正常的结束这次数据流，它会回调onCompleted()方法。

onErrorResumeNext():
如果某数据项出现异常了，如果使用onErrorResumeNext(),它可以用正常的数据来代替我们要发送给观察者的数据。区别就是可以用正常的数据做替换，然后发送。

onExceptionResumeNext():
可以让我们捕获操作异常的。

10.6.2 Retry

重新尝试修复完善
当错误发生的时候，尝试去恢复这个错误以保证正常的发送数据到观察者。

Retry():
当错误发生的时候，尝试去恢复这个错误以保证正常的发送数据到观察者
retryWhen():
当异常发生的时候，retryWhen()可以设置延长多少时间后，再来继续报这个错误，即发生异常的时候，不报这个错误，然后直到数据发送完成之后，我们才把异常信息回调给观察者，然后才捕获到异常信息。

11.Schedulers(调度器)

11.1 Schedulers(调度器)是什么？

调度器(Schedulers)是RxJava以一种极其简单的方式解决多线程问题机制.

11.2 Schedulers(调度器)种类

11.2.1 io()

这个调度器用于I/O操作
解说:在Android开发中，有很多种耗时的操作，比如网络操作，对一个磁盘的读写操作，这类都属于耗时的操作，这种耗时的操作就将其指定到I/O操作中。

11.2.2 computation()

这个是计算工作默认的调度器，它与I/O操作无关。
例如：buffer(),debounce(),delay(),interval(),sample(),skip();

11.2.3 immediate()

这个调度器允许你立即在当前线程执行你指定的工作。

11.2.4 newThread()

它为指定任务启动一个新的线程来执行我们的任务.

11.2.5 trampoline()

调度器将会按序列处理队列，并运行队列中每一个任务。
例如：应用操作符repeat()与retry()时。

12.Android Schedulers

12.1 Android Schedulers是什么？

AndroidSchedulers是RxAndroid库提供在安卓平台的调度器（指定观察者在主线程）
可以指定观察者在主线程中运行.
将数据的更新指定在主线程中进行绑定显示。

12.2 代码示例

    getApps()
	.onBackpressureBuffer()
	.subscribeOn(Schedulers.io())
	.observeOn(AndroidSchedulers.mainThread())
	.subscribe(new Observer<AppInfo>(){[…]})

13.非阻塞I/O操作

13.1 非阻塞I/O操作图片保存

    Public static void storeBitmap(Context context,Bitmap bitmap,String filename){
   		Schedulers.io().createWorker().schedule(()->{
      		blockingStoreBitmap(context,bitmap,filename);
		});
	}

阻塞 是同步，非阻塞是异步，在不同的线程中操作。

14.SubscribeOn and ObserveOn

解说：这两个操作符可以指定代码操作在什么线程上面。指定耗时操作在什么线程上执行。

14.1 SubscribeOn

RxJava提供了subscribeOn()方法来用于每个Observable对象.
即被观察者对象产生的操作具体的运行在哪个线程上面。

14.2 ObserveOn

RxJava提供了subscribeOn()方法来用于每个Subscriber(Observer)对象.
指定观察者对象的操作所在的线程.

	DataManager.getRetrofitService()
	.getHomeData(“homeDataVersion”,new HashMap<String,String>())
	.subscribeOn(Schedulers.io())//指定网络请求在io线程上
	.observeOn(AndroidSchedulers.mainThread())//指定数据返回在主线程上 
	.subscribe(subscriber);

4个东西，被观察者、观察者、操作符、调度器
操作符是对我们被观察者的数据进行的一些操作，操作完成之后将这些数据不管是变化也好，还是过滤也好，等等得到所想要的数据，
所想要的被观察者对象，然后将其发送给观察者。