2. Observable的创建

JiangMing 2019/12/30 Rxjava2

# 简要：

几种主要的需求

直接创建一个Observable（创建操作）
组合多个Observable（组合操作）
对Observable发射的数据执行变换操作（变换操作）
从Observable发射的数据中取特定的值（过滤操作）
转发Observable的部分值（条件/布尔/过滤操作）
对Observable发射的数据序列求值（算术/聚合操作）

创建Observable的各种方式

create()：使用一个函数从头创建一个Observable
defer()：只有当订阅者订阅才创建Observable；为每个订阅创建一个新的 Observable
empty() ：创建一个什么都不做直接通知完成的Observable
never()：创建一个不发射任何数据的Observable
error()：—创建一个什么都不做直接通知错误的Observable
just()：将一个或多个对象转换成发射这个或这些对象的一个Observable
from()：将一个Iterable, 一个Future, 或者一个数组转换成一个Observable
repeat()：创建一个重复发射指定数据或数据序列的Observable
repeatWhen() ：创建一个重复发射指定数据或数据序列的Observable，它依赖于另一个Observable发射的数据
repeatUntil()：根据条件（函数BooleanSupplier）判断是否需要继续订阅
range()：创建一个发射指定范围的整数序列的Observable
interval()：创建一个按照给定的时间间隔发射整数序列的Observable
timer()：—创建一个在给定的延时之后发射单个数据的Observable

# 1. Create

使用 Create 操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数，编写这个函数可以调用观察者的 onNext，onError 和 onCompleted 方法，当发生订阅的时候会自动调用观察者的 onSubscribe 方法。

通过 Subscribe 进行Observable 与 Observer 的订阅，其中 subscribe 方法可以接收一个完整通知参数的 Observer 对象，也可以接收部分通知参数的 Consumer(接收数据) 或者 Action (仅接收通知) 对象。

img-create

实例代码：

	// 创建Observable(被观察者)
	Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {

		public void subscribe(ObservableEmitter<String> emitter) throws Exception {
			emitter.onNext("Hello");
			emitter.onNext("World");
			emitter.onComplete();
		}
	});
	
	// 创建Observer(观察者), 可以接受所有通知
	Observer<String> observer = new Observer<String>() {

		public void onSubscribe(Disposable d) {
			System.out.println("--> onSubscribe");
		}

		public void onNext(String t) {
			System.out.println("--> onNext = " + t);
		}

		public void onError(Throwable e) {
			System.out.println("--> onError");
		}

		public void onComplete() {
			System.out.println("--> onComplete");
		}
	};
	
	// 创建只接受 onNext(item) 通知的Consumer(观察者)
	Consumer<String> nextConsumer = new Consumer<String>() {

		@Override
		public void accept(String t) throws Exception {
			System.out.println("--> accept nextConsumer: " + t);
		}
	};
	
	// 创建只接受 onError(Throwable) 通知的Consumer(观察者)
	Consumer<Throwable> errorConsumer = new Consumer<Throwable>() {

		@Override
		public void accept(Throwable t) throws Exception {
			System.out.println("-- accept errorConsumer: " + t);
		}
	};
	
	// 创建只接受 onComplete() 通知的Action(观察者)
	Action completedAction = new Action() {
		
		@Override
		public void run() throws Exception {
			System.out.println("--> run completedAction");
		}
	};
	
	// 创建只接受 onSubscribe 通知的Consumer(观察者)
	Consumer<Disposable> onSubscribeComsumer = new Consumer<Disposable>() {

		@Override
		public void accept(Disposable t) throws Exception {
			System.out.println("--> accept onSubscribeComsumer ");
		}
	};

	// 1. 进行订阅，subscribe(Observer)
	observable.subscribe(observer);
	
	System.out.println("---------------------------------------------");
	// 2. 进行订阅，subscribe(Consumer onNext)
	observable.subscribe(nextConsumer);
	
	System.out.println("---------------------------------------------");
	// 3. 进行订阅，subscribe(Consumer onNext, Consumer onError)
	observable.subscribe(nextConsumer, errorConsumer);
	
	System.out.println("---------------------------------------------");
	// 4. 进行订阅，subscribe(Consumer onNext, Consumer onError, Action onCompleted)
	observable.subscribe(nextConsumer, errorConsumer, completedAction);
	
	System.out.println("---------------------------------------------");
	// 5. 进行订阅，subscribe(Consumer onNext, Consumer onError, Action onCompleted, Consumer onSubscribe)
	observable.subscribe(nextConsumer, errorConsumer, completedAction, onSubscribeComsumer);

输出：

--> onSubscribe
--> onNext = Hello
--> onNext = World
--> onComplete
---------------------------------------------
--> accept nextConsumer: Hello
--> accept nextConsumer: World
---------------------------------------------
--> accept nextConsumer: Hello
--> accept nextConsumer: World
---------------------------------------------
--> accept nextConsumer: Hello
--> accept nextConsumer: World
--> run completedAction
---------------------------------------------
--> accept onSubscribeComsumer 
--> accept nextConsumer: Hello
--> accept nextConsumer: World
--> run completedAction

注意：create 方法默认不在任何特定的调度器上执行。

onSubscribe(Disposable): 在发生订阅时接收。

onNext(item): 在被观察者发射数据接收。

onError(Throwable): 在被观察者发射Error时接收。

onComplete(): 在被观察者完成数据发送时接收。

Javadoc: create(OnSubscribe) (opens new window) Javadoc: subscribe() (opens new window)
Javadoc: subscribe(observer) (opens new window)
Javadoc: subscribe(onNext) (opens new window)
Javadoc: subscribe(onNext, onError) (opens new window)
Javadoc: subscribe(onNext, onError, onComplete) (opens new window)
Javadoc: subscribe(onNext, onError, onComplete, onSubscribe) (opens new window)

# 2. Defer

直到有观察者订阅时才创建 Observable，并且为每个观察者创建一个新的 Observable.

Defer 操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个 Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个 Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。

img-defer

实例代码：

	// 创建一个Defer类型的Observable
	Observable<Integer> deferObservable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
		public ObservableSource<? extends Integer> call() throws Exception {
			// 创建每个观察者订阅所返回的 Observable
			Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
	
				public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
					emitter.onNext(1);
					emitter.onNext(2);
					emitter.onNext(3);
					emitter.onNext(4);
					emitter.onNext(5);
					emitter.onComplete();
				}
			});
			return observable;
		}
	});
	
	// 创建第一个观察者并订阅defer Observable
	deferObservable.subscribe(new Consumer<Integer>() {
	
		public void accept(Integer t) throws Exception {
			System.out.println("No.1 --> accept = " + t);
		}
	});
	
	// 创建第二个观察者并订阅defer Observable
	deferObservable.subscribe(new Consumer<Integer>() {
	
		public void accept(Integer t) throws Exception {
			System.out.println("No.2 --> accept = " + t);
		}
	});
	
	// 创建第三个观察者并订阅defer Observable
	deferObservable.subscribe(new Consumer<Integer>() {
	
		public void accept(Integer t) throws Exception {
			System.out.println("No.3 --> accept = " + t);
		}
	});

输出：

No.1 --> accept = 1
No.1 --> accept = 2
No.1 --> accept = 3
No.1 --> accept = 4
No.1 --> accept = 5
No.2 --> accept = 1
No.2 --> accept = 2
No.2 --> accept = 3
No.2 --> accept = 4
No.2 --> accept = 5
No.3 --> accept = 1
No.3 --> accept = 2
No.3 --> accept = 3
No.3 --> accept = 4
No.3 --> accept = 5

注意：defer 方法默认不在任何特定的调度器上执行。
Javadoc: defer(Func0) (opens new window)

# 3. Empty/Never/Error

Empty：创建一个不发射任何数据但是正常终止的Observable Never：创建一个不发射数据也不终止的Observable Error：创建一个不发射数据以一个错误终止的Observable

这三个操作符生成的 Observable 行为非常特殊和受限，多用于一些特殊的场景（某些操作状态异常后返回一个error、empty、never 的 Observable）。测试的时候很有用，有时候也用于结合其它的 Observables，或者作为其它需要 Observable 的操作符的参数。

实例代码：

	System.out.println("--> 1 -----------------------------------");
	// 1.  创建一个不发射任何数据但是正常终止的Observable
	Observable.empty()
		.subscribe(new Observer<Object>() {
	
			@Override
			public void onSubscribe(Disposable d) {
				System.out.println("onSubscribe");
			}
	
			@Override
			public void onNext(Object t) {
				System.out.println("onNext: " + t);
			}
	
			@Override
			public void onError(Throwable e) {
				System.out.println("onError: " + e);
			}
	
			@Override
			public void onComplete() {
				System.out.println("onComplete");
			}
		});
	
	System.out.println("--> 2 -----------------------------------");
	// 2.  创建一个不输出数据，并且不会终止的Observable
	Observable.never()
		.subscribe(new Observer<Object>() {
	
			@Override
			public void onSubscribe(Disposable d) {
				System.out.println("onSubscribe");
			}
	
			@Override
			public void onNext(Object t) {
				System.out.println("onNext: " + t);
			}
	
			@Override
			public void onError(Throwable e) {
				System.out.println("onError: " + e);
			}
	
			@Override
			public void onComplete() {
				System.out.println("onComplete");
			}
		});
	
	System.out.println("--> 3 -----------------------------------");
	// 3.  创建一个不发射数据以一个错误终止的Observable
	Observable.error(new NullPointerException("error test"))
		.subscribe(new Observer<Object>() {
	
			@Override
			public void onSubscribe(Disposable d) {
				System.out.println("onSubscribe");
			}
	
			@Override
			public void onNext(Object t) {
				System.out.println("onNext: " + t);
			}
	
			@Override
			public void onError(Throwable e) {
				System.out.println("onError: " + e);
			}
	
			@Override
			public void onComplete() {
				System.out.println("onComplete");
			}
		});

输出：

--> 1 -----------------------------------
onSubscribe
onComplete
--> 2 -----------------------------------
onSubscribe
--> 3 -----------------------------------
onSubscribe
onError: java.lang.NullPointerException: error test

注意：

RxJava将这些操作符实现为 empty，never和 error。

error 操作符需要一个 Throwable参数，你的Observable会以此终止。

这些操作符默认不在任何特定的调度器上执行，但是 empty 和 error 有一个可选参数是Scheduler，如果你传递了Scheduler参数，它们会在这个调度器上发送通知.
Javadoc: empty() (opens new window)
Javadoc: never() (opens new window)
Javadoc: error(java.lang.Throwable) (opens new window)

# 4. Just

创建一个发射指定值的Observable。

Just 将单个数据转换为发射那个数据的Observable。类似于From，但是From会将数组或Iterable的数据取出然后逐个发射，而Just只是简单的原样发射，将数组或Iterable当做单个数据。

注意： 如果你传递 null 给 Just，它会返回一个发射 null 值的 Observable。不要误认为它会返回一个空Observable（完全不发射任何数据的Observable），如果需要空Observable你应该使用Empty操作符。 img-just

实例代码：

	// 单个对象发送
	Observable.just(1)
			.subscribe(new Consumer<Integer>() {

				public void accept(Integer t) throws Exception {
					System.out.println("--> singe accept: " + t);
				}
			});
	
	System.out.println("---------------------------------");
	// 多个对象发送，内部实际使用from实现 (接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable)
	Observable.just(1, 2, 3, 4, 5)
			.subscribe(new Consumer<Integer>() {

				public void accept(Integer t) throws Exception {
					System.out.println("--> mutil accept: " + t);
				}
			});

输出：

--> singe accept: 1
---------------------------------
--> mutil accept: 1
--> mutil accept: 2
--> mutil accept: 3
--> mutil accept: 4
--> mutil accept: 5

Javadoc: just(item ...) (opens new window)

# 5. From

将其它种类的对象和数据类型转换为Observable，发射来自对应数据源数据类型的数据，在RxJava中，from 操作符可以转换 Future 、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。 img-from

实例代码：

		// 初始化数据
		Integer[] array = { 1, 2, 3, 4, 5, 6 };
		List<String> iterable = new ArrayList<String>();
		iterable.add("A");
		iterable.add("B");
		iterable.add("C");
		iterable.add("D");
		iterable.add("E");
		
		// 1. fromArray
		Observable.fromArray(array).subscribe(new Consumer<Integer>() {

			@Override
			public void accept(Integer t) throws Exception {
				System.out.println("--> accept(1):fromArray: " + t);
			}
		});
		
		System.out.println("---------------------------------------");
		// 2. fromIterable
		Observable.fromIterable(iterable)
			.subscribe(new Consumer<String>() {

				@Override
				public void accept(String t) throws Exception {
					System.out.println("--> accept(2) fromIterable: " + t);
				}
			});
		
		System.out.println("---------------------------------------");
		// 3. fromCallable
		Observable.fromCallable(new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				return 1;
			}
		}).subscribe(new Consumer<Integer>() {

			@Override
			public void accept(Integer t) throws Exception {
				System.out.println("--> accept(3): fromCallable: " + t);
			}
		});
		
		System.out.println("---------------------------------------");
		// 4. fromFuture
		Observable.fromFuture(new Future<String>() {

			@Override
			public boolean cancel(boolean mayInterruptIfRunning) {
				return false;
			}

			@Override
			public String get() throws InterruptedException, ExecutionException {
				System.out.println("--> fromFutrue: get()");
				return "hello";
			}

			@Override
			public boolean isCancelled() {
				return false;
			}

			@Override
			public boolean isDone() {
				return false;
			}

			@Override
			public String get(long timeout, TimeUnit unit)
					throws InterruptedException, ExecutionException, TimeoutException {
				return null;
			}
		}).subscribe(new Consumer<String>() {

			@Override
			public void accept(String t) throws Exception {
				System.out.println("--> accept(4): fromFuture： " + t);
			}
		});

输出：

--> accept(1):fromArray: 1
--> accept(1):fromArray: 2
--> accept(1):fromArray: 3
--> accept(1):fromArray: 4
--> accept(1):fromArray: 5
--> accept(1):fromArray: 6
---------------------------------------
--> accept(2) fromIterable: A
--> accept(2) fromIterable: B
--> accept(2) fromIterable: C
--> accept(2) fromIterable: D
--> accept(2) fromIterable: E
---------------------------------------
--> accept(3): fromCallable: 1
---------------------------------------
--> fromFutrue: get()
--> accept(4): fromFuture： hello

注意：from默认不在任何特定的调度器上执行。然而你可以将Scheduler作为可选的第二个参数传递给Observable，它会在那个调度器上管理这个Future。
Javadoc: from(array) (opens new window)
Javadoc: from(Iterable) (opens new window)
Javadoc: from(Callable) (opens new window)
Javadoc: from(Future) (opens new window)
Javadoc: from(Future,Scheduler) (opens new window)
Javadoc: from(Future,timeout,timeUnit) (opens new window)

# 6. Repeat

创建一个发射特定数据重复多次的Observable，它不是创建一个Observable，而是重复发射原始 Observable的数据序列，这个序列或者是无限的，或者通过 repeat(n) 指定重复次数。 img-repeat

实例代码：

	// 1. repeat(): 一直重复发射原始 Observable的数据序列
	Observable.range(1, 5)
			.repeat()
			.subscribe(new Consumer<Integer>() {

				@Override
				public void accept(Integer t) throws Exception {
					System.out.println("--> accept(1): " + t);
				}
			});
	
	System.out.println("----------------------------------------");
	// 2. repeat(n): 重复执行5次
	Observable.range(1, 2)
			.repeat(3)
			.subscribe(new Consumer<Integer>() {

				@Override
				public void accept(Integer t) throws Exception {
					System.out.println("--> accept(2): " + t);
				}
			});

输出：

--> accept(1): 1
--> accept(1): 2
--> accept(1): 3
--> accept(1): 4
--> accept(1): 5
--> accept(1): 1
--> accept(1): 2
--> accept(1): 3
--> accept(1): 4
--> accept(1): 5
--> accept(1): 1
--> accept(1): 2
--> accept(1): 3
--> accept(1): 4
--> accept(1): 5
......
----------------------------------------
--> accept(2): 1
--> accept(2): 2
--> accept(2): 1
--> accept(2): 2
--> accept(2): 1
--> accept(2): 2

注意： repeat 操作符默认在 trampoline 调度器上执行。有一个变体可以通过可选参数指定 Scheduler。
Javadoc: repeat() (opens new window)
Javadoc: repeat(long) (opens new window)
Javadoc: repeat(Scheduler) (opens new window)
Javadoc: repeat(long,Scheduler) (opens new window)

# 7. RepeatWhen

repeatWhen的操作符，它不是缓存和重放原始 Observable 的数据序列，接收到原始 Observable 终止通知后，有条件的决定是否重新订阅原来的 Observable 。

将原始 Observable 的终止通知（完成或错误）当做一个 void 数据传递给一个通知处理器，它以此来决定是否要重新订阅和发射原来的 Observable。这个通知处理器就像一个 Observable 操作符，接受一个发射 void通知的 Observable为输入，返回一个发射 void 数据（意思是，重新订阅和发射原始 Observable）或者直接终止（意思是，使用 repeatWhen 终止发射数据）的 Observable。

img-repeatWhen

实例代码：

	// repeatWhen(Func1())：接收到终止通知后，在函数中决定是否重新订阅原来的Observable
	// 需要注意的是repeatWhen的objectObservable处理（也可以单独自定义Observable返回），这里使用flathMap进行处理，
	// 让它延时发出onNext，这里onNext发出什么数据都不重要，它只是仅仅用来处理重订阅的通知，如果发出的是onComplete/onError，则不会触发重订阅
	Observable.range(1, 2)
			.doOnComplete(new Action() {

				@Override
				public void run() throws Exception {
					System.out.println("-----------> 完成一次订阅");
				}
			}).repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
				private int n = 0;
				
				@Override
				public ObservableSource<?> apply(Observable<Object> t) throws Exception {
					// 接收到原始Observable的终止通知，决定是否重新订阅
					System.out.println("--> apply repeat ");
					return t.flatMap(new Function<Object, ObservableSource<?>>() {

						@Override
						public ObservableSource<?> apply(Object t) throws Exception {
							if(n < 3) {	// 重新订阅3次
								n ++;
								return Observable.just(0);   
							} else {
								return Observable.empty();
							}
						}
					});
					// return Observable.timer(1, TimeUnit.SECONDS);		// 间隔一秒后重新订阅一次
					// return Observable.interval(1, TimeUnit.SECONDS);	// 每间隔一秒重新订阅一次
				}
			}).subscribe(new Consumer<Integer>() {

				@Override
				public void accept(Integer t) throws Exception {
					System.out.println("--> accept: " + t);
				}
			});

输出：

--> apply repeat 
--> accept: 1
--> accept: 2
-----------> 完成一次订阅
--> accept: 1
--> accept: 2
-----------> 完成一次订阅
--> accept: 1
--> accept: 2
-----------> 完成一次订阅
--> accept: 1
--> accept: 2
-----------> 完成一次订阅

注意：repeatWhen操作符默认在 trampoline 调度器上执行。

Javadoc: repeatWhen(Func1) (opens new window)

# 8. RepeatUntil

根据条件（函数BooleanSupplier）判断是否需要继续订阅: false:继续订阅; true:取消订阅 img-repeatUntil

实例代码：

	// repeatUntil 根据条件（BooleanSupplier）判断是否需要继续订阅
	Observable.range(1, 2)
			.doOnComplete(new Action() {

				@Override
				public void run() throws Exception {
					System.out.println("-----------> 完成一次订阅");
				}
			}).repeatUntil(new BooleanSupplier() {

				private int n = 0;

				@Override
				public boolean getAsBoolean() throws Exception {
					System.out.println("getAsBoolean = " + (n < 3? false:true) );
					// 是否需要终止
					if (n < 3) {
						n++;
						return false; 	// 继续重新订阅
					}
					return true; 		// 终止重新订阅
				}
			}).subscribe(new Consumer<Integer>() {

				@Override
				public void accept(Integer t) throws Exception {
					System.out.println("--> accept: " + t);
				}
			});

输出：

--> accept: 1
--> accept: 2
-----------> 完成一次订阅
getAsBoolean = false
--> accept: 1
--> accept: 2
-----------> 完成一次订阅
getAsBoolean = false
--> accept: 1
--> accept: 2
-----------> 完成一次订阅
getAsBoolean = false
--> accept: 1
--> accept: 2
-----------> 完成一次订阅
getAsBoolean = true

Javadoc: repeatWhen(Func1) (opens new window)

# 9. Range

创建一个发射特定整数序列的Observable。

Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度。

RxJava将这个操作符实现为 range 函数，它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。 img-range

实例代码：

	// 1. range(n,m) 发射从n开始的m个整数序列，序列区间[n,n+m-1)
	Observable.range(0, 5)
			.subscribe(new Consumer<Integer>() {

				@Override
				public void accept(Integer t) throws Exception {
					System.out.println("-- accept(range): " + t);
				}
			});
	
	System.out.println("------------------------------");
	// 2. rangeLong(n,m) 发射从n开始的m个长整型序列，序列区间[n,n+m-1)
	Observable.rangeLong(1, 5)
			.subscribe(new Consumer<Long>() {

				@Override
				public void accept(Long t) throws Exception {
					System.out.println("-- accept(rangeLong): " + t);
				}
			});

输出：

-- accept(range): 0
-- accept(range): 1
-- accept(range): 2
-- accept(range): 3
-- accept(range): 4
------------------------------
-- accept(rangeLong): 1
-- accept(rangeLong): 2
-- accept(rangeLong): 3
-- accept(rangeLong): 4
-- accept(rangeLong): 5

Javadoc: range(int start,int count) (opens new window)
Javadoc: rangeLong(long start, long count) (opens new window)

# 10. interval

创建一个按固定时间间隔发射整数序列的Observable，它按固定的时间间隔发射一个无限递增的整数序列。 RxJava将这个操作符实现为 interval 方法。它接受一个表示时间间隔的参数和一个表示时间单位的参数。 img-interval

实例代码：

	// [1] interval(long period, TimeUnit unit) 
	// 每间隔period时间单位，发射一次整数序列
	Observable.interval(1, TimeUnit.SECONDS)
			.subscribe(new Consumer<Long>() {

				public void accept(Long l) throws Exception {
					System.out.println("--> accept(1): " + l);
				}
			});

	System.out.println("------------------------------------");
	// [2] interval(long initialDelay, long period, TimeUnit unit)
	// 在延迟initialDelay秒后每隔period时间单位发射一个整数序列
	Observable.interval(0, 1, TimeUnit.SECONDS)
			.subscribe(new Consumer<Long>() {

				public void accept(Long t) throws Exception {
					System.out.println("--> accept(2): " + t);
				}
			});
	
	System.out.println("------------------------------------");
	// [3] intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
	// 延迟initialDelay秒后从起始数据start开始，每隔period秒发送一个数字序列，一共发送count个数据
	Observable.intervalRange(1, 5, 3, 2, TimeUnit.SECONDS)
			.subscribe(new Consumer<Long>() {

				public void accept(Long t) throws Exception {
					System.out.println("--> accept(3): " + t);
				}
			});

注意：interval 默认在 computation 调度器上执行，有一个变体可以通过可选参数指定 Scheduler。
Javadoc: interval(long period, TimeUnit unit) (opens new window)
Javadoc: interval(long period, TimeUnit unit, Scheduler scheduler) (opens new window)
Javadoc: interval(long initialDelay, long period, TimeUnit unit) (opens new window)
Javadoc: interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) (opens new window)
Javadoc: intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit) (opens new window)
Javadoc: intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler) (opens new window)

输出：

--> accept(1): 0
--> accept(1): 1
--> accept(1): 2
--> accept(1): 3
--> accept(1): 4
--> accept(1): 5
...
------------------------------------
--> accept(2): 0
--> accept(2): 1
--> accept(2): 2
--> accept(2): 3
--> accept(2): 4
--> accept(2): 5
...
------------------------------------
--> accept(3): 1
--> accept(3): 2
--> accept(3): 3
--> accept(3): 4
--> accept(3): 5

# 11. Timer

创建一个给定的延迟后发射一个特殊的值的Observable。

RxJava将这个操作符实现为 timer 函数。timer 返回一个Observable，它在延迟一段给定的时间后发射一个简单的数字0 img-timer

实例代码：

	// timer(long delay, TimeUnit unit, Scheduler scheduler)
	// 定时delay时间 单位后发送数字0，指定可选参数Schedule调度器为trampoline(当前线程排队执行)
	Observable.timer(5, TimeUnit.SECONDS, Schedulers.trampoline())
			.subscribe(new Consumer<Long>() {

				@Override
				public void accept(Long t) throws Exception {
					System.out.println("--> accept: " + t);
				}
			});

输出：

--> accept: 0

注意：timer 操作符默认在 computation 调度器上执行。有一个变体可以通过可选参数指定 Scheduler。
Javadoc: timer(long delay, TimeUnit unit) (opens new window)
Javadoc: timer(long delay, TimeUnit unit, Scheduler scheduler) (opens new window)

# 小结

根据实际情况，使用不同的方式创建不同种类的Observable，这个在开发中非常有用，可以减少很多重复、复杂、冗余的操作，可以快速的创建一个符合要求的Observable，一定程度上提高了开发的效率。

提示：以上使用的Rxjava2版本: 2.2.12 (opens new window)

实例代码：

代码下载 (opens new window)

Github (opens new window)

Gitee（码云） (opens new window)

1. Rxjava2详细介绍 3. Observable的数据变换（一）

江明的个人网站

Choose mode