添加链接 注册    登录
link之家
链接快照平台
  • 输入网页链接，自动生成快照
  • 标签化管理网页链接
相关文章推荐
爱笑的蜡烛  ·  国家京剧院“致春天”-光明日报-光明网·  1 年前    · 
烦恼的日记本  ·  千金被保镖�%8 - 搜狗图片搜索·  1 年前    · 
气宇轩昂的蜡烛  ·  ID.Buzz超预期 ...·  2 年前    · 
旅行中的充值卡  ·  团宠小奶娃古风漫画_团宠奶娃的小说古风_女主 ...·  2 年前    · 
豁达的匕首  ·  第6话(1/2) - 请输入激活密码 - 包子漫画·  2 年前    · 
link之家  ›  Rxjava2 Observable的创建详解及实例 - JiangMing-JIM
https://www.cnblogs.com/jiangming-blogs/p/12127246.html
干练的地瓜
1 年前

目录

几种主要的需求

  • 直接创建一个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 (仅接收通知) 对象。

    实例代码： 

    	// 创建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)
    
Javadoc: subscribe()
    
Javadoc: subscribe(observer)
    
Javadoc: subscribe(onNext)
    
Javadoc: subscribe(onNext, onError)
    
Javadoc: subscribe(onNext, onError, onComplete)
    
Javadoc: subscribe(onNext, onError, onComplete, onSubscribe)
    

    2. Defer
    

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

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

    实例代码：
    

    	// 创建一个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)
    

    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()
    
Javadoc:	never()
    
Javadoc:	error(java.lang.Throwable)
    • 

    4. Just
    

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

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

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

    实例代码：
    

    	// 单个对象发送
	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 ...)
    

    5. From
    

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

    实例代码：
    

    		// 初始化数据
		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)
    
Javadoc: from(Iterable)
    
Javadoc: from(Callable)
    
Javadoc: from(Future)
    
Javadoc: from(Future,Scheduler)
    
Javadoc: from(Future,timeout,timeUnit)
    

    6. Repeat
    

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

    实例代码：
    

    	// 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()
    
Javadoc: repeat(long)
    
Javadoc: repeat(Scheduler)
    
Javadoc: repeat(long,Scheduler)
    

    7. RepeatWhen
    

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

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

    实例代码：
    

    	// 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)
    

    8. RepeatUntil
    

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

    实例代码：
    

    	// 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) {
						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)
    

    9. Range
    

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

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

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

    实例代码：
    

    	// 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)
    
Javadoc: rangeLong(long start, long count)
    

    10. interval
    

    创建一个按固定时间间隔发射整数序列的Observable，它按固定的时间间隔发射一个无限递增的整数序列。
    
RxJava将这个操作符实现为	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)
    
Javadoc: interval(long period, TimeUnit unit, Scheduler scheduler)
    
Javadoc: interval(long initialDelay, long period, TimeUnit unit)
    
Javadoc: interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
    
Javadoc: intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
    
Javadoc: intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
    

    --> 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
    

    实例代码：
    

    	// 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)
    
Javadoc: timer(long delay, TimeUnit unit, Scheduler scheduler)
    

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

    提示：以上使用的Rxjava2版本: 2.2.12
    

    Rx介绍与讲解及完整目录参考：Rxjava2 介绍与详解实例
    

    实例代码：
    

  • Github
    • 

  • Gitee（码云）
    •
     
    推荐文章
    爱笑的蜡烛  ·  国家京剧院“致春天”-光明日报-光明网
    1 年前
    烦恼的日记本  ·  千金被保镖�%8 - 搜狗图片搜索
    1 年前
    气宇轩昂的蜡烛  ·  ID.Buzz超预期 大众商用车全球销量32.87万 - 车质网
    2 年前
    旅行中的充值卡  ·  团宠小奶娃古风漫画_团宠奶娃的小说古风_女主是小奶娃的团宠漫画 - 抖音
    2 年前
    豁达的匕首  ·  第6话(1/2) - 请输入激活密码 - 包子漫画
    2 年前
    今天看啥   ·   Py中国   ·   codingpro   ·   小百科   ·   link之家   ·   卧龙AI搜索
    删除内容请联系邮箱 2879853325@qq.com
    link之家 - 链接快照平台
    © 2024 ~ 沪ICP备11025650号