常用rxjava操作符

2024-08-29 15:38
文章标签 java 常用 操作符 rx

本文主要是介绍常用rxjava操作符，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

RxJava 操作符

阅读本文前请先了解 RxJava 的基本使用。转自 http://blog.csdn.net/u014165119/article/details/52582782

参考文档：

  • RxJava JavaDoc
  • ReactiveX文档中文翻译

1 Observable 的创建

1.1 from( )

转换集合为一个每次发射集合中一个元素的 Observable 对象。可用来遍历集合。

方法列表：

  • public static <T> Observable<T> from(Future<? extends T> future)

  • public static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit)

  • public static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler)

  • public static <T> Observable<T> from(Iterable<? extends T> iterable)

  • public static <T> Observable<T> from(T[] array)

栗子：

// 1. 遍历集合
Observable<String> observable = Observable.from(new String[]{"hello", "hi"});
  • 1
  • 2
  • 1
  • 2
// 2. 使用 Future 创建 Observable，Future 表示一个异步计算的结果。
FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {@Overridepublic String call() throws Exception {// TODO 执行异步操作并返回数据return "hihi";}
});Scheduler.Worker worker = Schedulers.io().createWorker();
worker.schedule(new Action0() {@Overridepublic void call() {futureTask.run();}
});Observable<String> observable = Observable.from(futureTask);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

1.2 just( )

转换一个或多个 Object 为依次发射这些 Object 的 Observable 对象。

方法列表：

  • public static <T> Observable<T> just(final T value)

  • public static <T> Observable<T> just(T t1, T t2)

  • public static <T> Observable<T> just(T t1, T t2, T t3)

  • public static <T> Observable<T> just(T t1, T t2, T t3, T t4)

  • public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5)

  • public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6)

  • public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7)

  • public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8)

  • public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9)

  • public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9, T t10)

栗子：

Observable<String> observable = Observable.just("hello");// 使用 just() 遍历几个元素
Observable<String> observable = Observable.just("hello", "hi", "...");// 使用 from() 方法遍历，效果和 just() 一样。
String[] stringArrs = new String[]{"hello", "hi", "..."};
Observable<String> observable = Observable.from(stringArrs);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

just() 方法可传入 1~10 个参数，也就说当元素个数小于等于 10 的时候既可以使用 just() 也可以使用from()，否则只能用 from() 方法。

1.3 create( )

返回一个在被 OnSubscribe 订阅时执行特定方法的 Observable 对象。

方法列表：

  • public static <T> Observable<T> create(OnSubscribe<T> f)

  • @Beta public static <S, T> Observable<T>create(SyncOnSubscribe<S, T> syncOnSubscribe)

  • @Experimental public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe)

栗子：

Observable.OnSubscribe<String> onSubscribe = new Observable.OnSubscribe< String >() {@Overridepublic void call(Subscriber<? super String > subscriber) {// onNext() 方法可执行多次subscribe.onNext("hello");subscribe.onCompleted();}
};
Observable<Object> observable = Observable.create(onSubscribe);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

此方法不常用，大多数时候都是使用 just( )、form( ) 等方法，如上面那串代码就可以写成：

Observable<Object> observable = Observable.just("hello");
  • 1
  • 1

1.4 interval( )

返回一个每隔指定的时间间隔就发射一个序列号的 Observable 对象，可用来做倒计时等操作。

方法列表：

  • public static Observable<Long> interval(long interval, TimeUnit unit)

  • public static Observable<Long> interval(long interval, TimeUnit unit, Scheduler scheduler)

  • public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit)

  • public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)

栗子：

// 每隔 1 s 发送一个序列号，序列号从 0 开始，每次累加 1。
Observable<Long> observable = Observable.interval(1, TimeUnit.SECONDS);
  • 1
  • 2
  • 1
  • 2

1.5 timer( )

创建一个在指定延迟时间后发射一条数据（ 固定值：0 ）的 Observable 对象，可用来做定时操作。

方法列表：

  • public static Observable<Long> timer(long delay, TimeUnit unit)

  • public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler)

栗子：

// 定时 3 s
Observable<Long> observable = Observable.timer(3, TimeUnit.SECONDS);
  • 1
  • 2
  • 1
  • 2

1.6 range( )

创建一个发射指定范围内的连续整数的 Observable 对象。

方法列表：

  • public static Observable<Integer> range(int start, int count)

  • public static Observable<Integer> range(int start, int count, Scheduler scheduler)

栗子：

// 依次发射 5、6、7
Observable<Integer> observable = Observable.range(5, 3);
  • 1
  • 2
  • 1
  • 2

1.7 empty()

创建一个不发射任何数据就发出 onCompleted() 通知的 Observable 对象。

方法列表：

  • public static <T> Observable<T> empty()

栗子：

// 发出一个 onCompleted() 通知
Observable<Object> observable = Observable.empty();
  • 1
  • 2
  • 1
  • 2

1.8 error( )

创建不发射任何数据就发出 onError 通知的 Observable 对象。

方法列表：

  • public static <T> Observable<T> error(Throwable exception)

栗子：

// 发出一个 onError() 通知
Observable<Object> observable = Observable.error(new Throwable("message"));
  • 1
  • 2
  • 1
  • 2

1.9 never()

创建一个不发射任何数据和通知的 Observable 对象。

方法列表：

  • public static <T> Observable<T> never()

栗子：

Observable<Object> observable = Observable.never();
  • 1
  • 1

1.10 defer( )

在订阅的时候才会创建 Observable 对象；每一次订阅都创建一个新的 Observable 对象。

方法列表：

  • public static <T> Observable<T> defer(Func0<Observable<T>> observableFactory)

栗子：

Observable<String> observable = Observable.defer(new Func0<Observable<String>>() {@Overridepublic Observable<String> call() {return Observable.just("string");}
});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

2 重做

2.1 repeat( )

使Observable 对象在发出 onNext() 通知之后重复发射数据。重做结束才会发出 onComplete() 通知，若重做过程中出现异常则会中断并发出onError() 通知。

方法列表：

  • public final Observable<T> repeat()

  • public final Observable<T> repeat(final long count)

  • public final Observable<T> repeat(Scheduler scheduler)

  • public final Observable<T> repeat(final long count, Scheduler scheduler)

栗子：

Observable<String> observable = Observable.just("string");
// 无限重复执行
observable.repeat();
// 重复执行 5 次
observable.repeat(5);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

2.2 repeatWhen( )

使Observable 对象在发出 onNext() 通知之后有条件的重复发射数据。重做结束才会发出 onCompleted() 通知，若重做过程中出现异常则会中断并发出onError() 通知。

方法列表：

  • public final Observable<T> repeatWhen(final Func1<? super Observable<? extends Void>, ? extends Observable<?>> notificationHandler)

  • public final Observable<T> repeatWhen(final Func1<? super Observable<? extends Void>, ? extends Observable>?> notificationHandler, Scheduler scheduler)

栗子：

observable.repeatWhen(new Func1<Observable<? extends Void>, Observable<?>>() {@Overridepublic Observable<?> call(Observable<? extends Void> observable) {// 重复 3 次, 每次间隔 1 sreturn observable.zipWith(Observable.range(1, 3), new Func2<Void, Integer, Integer>() {@Overridepublic Integer call(Void aVoid, Integer integer) {return integer;}}).flatMap(integer -> Observable.timer(1, TimeUnit.SECONDS));}
});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

3 重试

3.1 retry( )

在执行 Observable对象的序列出现异常时，不直接发出 onError() 通知，而是重新订阅该 Observable对象，直到重做过程中未出现异常，则会发出 onNext() 和 onCompleted() 通知；若重做过程中也出现异常，则会继续重试，直到达到重试次数上限，超出次数后发出最新的onError() 通知。

方法列表：

  • public final Observable<T> retry()

  • public final Observable<T> retry(final long count)

  • public final Observable<T> retry(Func2<Integer, Throwable, Boolean> predicate)

栗子：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {@Overridepublic void call(Subscriber<? super Integer> subscriber) {System.out.println(".......");int a = 1 / 0;subscriber.onNext(a);subscriber.onCompleted();}
});
// 无限次的重试
observable.retry();
// 重试 3 次
observable.retry(3);
// 使用谓语函数决定是否重试
observable.retry(new Func2<Integer, Throwable, Boolean>() {@Overridepublic Boolean call(Integer integer, Throwable throwable) {// 参数 integer 是订阅的次数; 参数 throwable 是抛出的异常// 返回值为 true 表示重试, 返回值为 false 表示不重试return false;}
});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

3.2 retryWhen( )

作用： 有条件的执行重试。

方法列表：

  • public final Observable<T> retryWhen(final Func1<? super Observable<? extends Throwable>, ? extends Observable<?>> notificationHandler)

  • public final Observable<T> retryWhen(final Func1<? super Observable<? extends Throwable>, ? extends Observable<?>>notificationHandler, Scheduler scheduler)

栗子：

// 重试 3 次，每次间隔 1 s
observable.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {@Overridepublic Observable<?> call(Observable<? extends Throwable> observable) {return observable.zipWith(Observable.range(1, 3), new Func2<Throwable, Integer, Object>() {@Overridepublic Object call(Throwable throwable, Integer integer) {return integer;}}).flatMap(new Func1<Object, Observable<?>>() {@Overridepublic Observable<?> call(Object o) {return Observable.timer(1, TimeUnit.SECONDS);}});}
});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

4 变换

4.1 map( )

把源 Observable 发射的元素应用于指定的函数，并发送该函数的结果。

方法列表：

  • public final <R> Observable<R> map(Func1<? super T, ? extends R> func)

栗子：

Observable.just(2).map(new Func1<Integer, String>() {@Overridepublic String call(Integer integer) {return String.valueOf(String.format("原始数据的两倍为: %s", integer * 2));}});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

4.2 flatMap( )

转换源 Observable 对象为另一个 Observable 对象。

方法列表：

  • public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> func)

  • @Beta public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> func, int maxConcurrent)

  • public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> onNext, Func1<? super Throwable, ? extends Observable<? extends R>> onError, Func0<? extends Observable<? extends R>> onCompleted)

  • @Beta public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> onNext, Func1<? super Throwable, ? extends Observable<? extends R>> onError, Func0<? extends Observable<? extends R>> onCompleted, int maxConcurrent)

  • public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Observable<? extends U>> collectionSelector, final Func2<? super T, ? super U, ? extends R> resultSelector)

  • @Beta public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Observable<? extends U>> collectionSelector, final Func2<? super T, ? super U, ? extends R> resultSelector, int maxConcurrent)

栗子：

Observable.just(2).flatMap(new Func1<Integer, Observable<Long>>() {@Overridepublic Observable<Long> call(Integer integer) {// 转换为一个定时 integer 秒的 Observable 对象return Observable.timer(integer, TimeUnit.SECONDS);}});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

5 过滤

5.1 filter( )

只发射满足指定谓词的元素。

方法列表：

  • public final Observable<T> filter(Func1<? super T, Boolean> predicate)

栗子：

Observable.just(-1, -2, 0, 1, 2).filter(new Func1<Integer, Boolean>() {@Overridepublic Boolean call(Integer integer) {return integer > 0;}});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

5.2 first( )

返回一个仅仅发射源 Observable 发射的第一个［满足指定谓词的］元素的 Observable，如果如果源 Observable 为空，则会抛出一个 NoSuchElementException。

方法列表：

  • public final Observable<T> first()

  • public final Observable<T> first(Func1<? super T, Boolean> predicate)

栗子：

// 发射第一个元素
Observable.just(-1, -2, 0, 1, 2).first();// 发射满足条件的第一个元素
Observable.just(-1, -2, 0, 1, 2).first(new Func1<Integer, Boolean>() {@Overridepublic Boolean call(Integer integer) {return integer > 0;}});// 会抛出 NoSuchElementException 异常
Observable.empty().first();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

5.3 last( )

返回一个仅仅发射源 Observable 发射的倒数第一个［满足指定谓词的］元素的 Observable，如果如果源 Observable 为空，则会抛出一个 NoSuchElementException。

方法列表：

  • public final Observable<T> last()

  • public final Observable<T> last(Func1<? super T, Boolean> predicate)

栗子：

// 发射倒数第一个元素
Observable.just(-1, -2, 0, 1, 2).first();// 发射满足条件的倒数第一个元素
Observable.just(-1, -2, 0, 1, 2).first(new Func1<Integer, Boolean>() {@Overridepublic Boolean call(Integer integer) {return integer < 0;}});// 会抛出 NoSuchElementException 异常
Observable.empty().last();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

5.4 skip( )

跳过前面指定数量或指定时间内的元素，只发射后面的元素。

方法列表：

  • public final Observable<T> skip(int count)

  • public final Observable<T> skip(long time, TimeUnit unit)

  • public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler)

栗子：

Observable.just(-1, -2, 0, 1, 2).skip(2) // 跳过前两条数据
  • 1
  • 2
  • 1
  • 2

5.5 skipLast( )

跳过前面指定数量或指定时间内的元素，只发射后面的元素。指定时间时会延迟源 Observable 发射的任何数据。

方法列表：

  • public final Observable<T> skipLast(int count)

  • public final Observable<T> skipLast(long time, TimeUnit unit)

  • public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler)

栗子：

Observable.just(-1, -2, 0, 1, 2).skip(2) // 跳过后两条数据
  • 1
  • 2
  • 1
  • 2

5.6 take( )

只发射前面指定数量或指定时间内的元素。

方法列表：

  • public final Observable<T> take(final int count)

  • public final Observable<T> take(long time, TimeUnit unit)

  • public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler)

栗子：

Observable.just(-1, -2, 0, 1, 2).take(3); // 只发射前三条数据
  • 1
  • 1

5.7 takeLast( )

只发射后面指定数量或指定时间内的元素。指定时间时会延迟源 Observable 发射的任何数据。

方法列表：

  • public final Observable<T> takeLast(final int count)

  • public final Observable<T> takeLast(int count, long time, TimeUnit unit)

  • public final Observable<T> takeLast(int count, long time, TimeUnit unit, Scheduler scheduler)

  • public final Observable<T> takeLast(long time, TimeUnit unit)

  • public final Observable<T> takeLast(long time, TimeUnit unit, Scheduler scheduler)

栗子：

Observable.just(-1, -2, 0, 1, 2).takeLast(3); // 只发射后三条数据
  • 1
  • 1

5.8 sample( )

定期发射 Observable 发射的最后一条数据。

方法列表：

  • public final Observable<T> sample(long period, TimeUnit unit)

  • public final Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler)

  • public final <U> Observable<T> sample(Observable<U> sampler)

栗子：

Observable.interval(300, TimeUnit.MILLISECONDS).sample(2, TimeUnit.SECONDS)
  • 1
  • 2
  • 1
  • 2

5.9 elementAt( )

只发射指定索引的元素。

方法列表：

  • public final Observable<T> elementAt(int index)

栗子：

Observable.just(-1, -2, 0, 1, 2).elementAt(2); // 发射索引为 2 的数据
  • 1
  • 1

5.10 elementAtOrDefault( )

只发射指定索引的元素，若该索引对应的元素不存在，则发射默认值。

方法列表：

  • public final Observable<T> elementAtOrDefault(int index, T defaultValue)

栗子：

Observable.just(-1, -2, 0, 1, 2).elementAtOrDefault(9, -5); // 发射索引为 9的数据，若不存在，则发射 -5
  • 1
  • 1

5.11 ignoreElements( )

不发射任何数据，直接发出 onCompleted() 通知。

方法列表：

  • public final Observable<T> ignoreElements()

栗子：

Observable.just(-1, -2, 0, 1, 2).ignoreElements()
  • 1
  • 1

5.12 distinct( )

过滤重复的元素，过滤规则是：只允许还没有发射过的元素通过。

方法列表：

  • public final Observable<T> distinct()

  • public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelector)

栗子：

// 直接过滤
Observable.just(-1, -2, 0, 1, 2, 1).distinct();// 通过生成的 key 值过滤
Observable.just(-1, -2, 0, 1, 2, 1).distinct(new Func1<Integer, Integer>() {@Overridepublic Integer call(Integer integer) {// 随机生成 keyreturn integer * (int)(Math.random() * 10);}
});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

5.13 debounce( )

源 Observable 每产生结果后，如果在规定的间隔时间内没有产生新的结果，则发射这个结果，否则会忽略这个结果。该操作符会过滤掉发射速率过快的数据项。

方法列表：

  • public final Observable<T> debounce(long timeout, TimeUnit unit)

  • public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler)

  • public final <U> Observable<T> debounce(Func1<? super T, ? extends Observable<U>> debounceSelector)

栗子：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {@Overridepublic void call(Subscriber<? super Integer> subscriber) {try {//产生结果的间隔时间分别为100、200、300...900毫秒for (int i = 1; i < 10; i++) {subscriber.onNext(i);Thread.sleep(i * 100);}subscriber.onCompleted();} catch (Exception e) {subscriber.onError(e);}}
});
observable.debounce(400, TimeUnit.MILLISECONDS)  // 超时时间为400毫秒
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

该栗子产生结果为：依次打印5、6、7、8。

附：功能实现

延时遍历

// 遍历
Observable<Integer> traverseObservable = Observable.just(3, 4, 5, 6);
// 计时
Observable<Long> intervalObservable = Observable.interval(1, TimeUnit.SECONDS);Func2<Long, Integer, Integer> func2 = new Func2<Long, Integer, Integer>() {@Overridepublic Integer call(Long aLong, Integer integer) {return integer;}
};intervalObservable.zipWith(traverseObservable, func2).toBlocking().subscribe(new Subscriber<Integer>() {@Overridepublic void onCompleted() {System.out.println("onCompleted");}@Overridepublic void onError(Throwable e) {e.printStackTrace();}@Overridepublic void onNext(Integer integer) {System.out.println(integer);}});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

倒计时

int startTime = 10;Observable.interval(0, 1, TimeUnit.SECONDS).take(startTime + 1) // 接收 startTime + 1 次.map(new Func1<Long, Long>() {@Overridepublic Long call(Long time) {// 1 2 3...转换为...3 2 1return startTime - time;}}).toBlocking().subscribe(new Subscriber<Long>() {@Overridepublic void onCompleted() {System.out.println("倒计时结束");}@Overridepublic void onError(Throwable e) {System.out.println("倒计时出现异常");e.printStackTrace();}@Overridepublic void onNext(Long aLong) {System.out.println(String.format("倒计时: %s s", aLong));}});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

这篇关于常用rxjava操作符的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1118270。

相关文章

springboot security快速使用示例详解

springboot security快速使用示例详解

《springbootsecurity快速使用示例详解》：本文主要介绍springbootsecurity快速使用示例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝... 目录创www.chinasem.cn建spring boot项目生成脚手架配置依赖接口示例代码项目结构启用s
阅读更多...
java之Objects.nonNull用法代码解读

java之Objects.nonNull用法代码解读

《java之Objects.nonNull用法代码解读》：本文主要介绍java之Objects.nonNull用法代码,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录Java之Objects.nonwww.chinasem.cnNull用法代码Objects.nonN
阅读更多...
springboot security之前后端分离配置方式

springboot security之前后端分离配置方式

《springbootsecurity之前后端分离配置方式》：本文主要介绍springbootsecurity之前后端分离配置方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的... 目录前言自定义配置认证失败自定义处理登录相关接口匿名访问前置文章总结前言spring boot secu
阅读更多...
一文详解SpringBoot响应压缩功能的配置与优化

一文详解SpringBoot响应压缩功能的配置与优化

《一文详解SpringBoot响应压缩功能的配置与优化》SpringBoot的响应压缩功能基于智能协商机制,需同时满足很多条件,本文主要为大家详细介绍了SpringBoot响应压缩功能的配置与优化,需... 目录一、核心工作机制1.1 自动协商触发条件1.2 压缩处理流程二、配置方案详解2.1 基础YAML
阅读更多...
java中使用POI生成Excel并导出过程

java中使用POI生成Excel并导出过程

《java中使用POI生成Excel并导出过程》：本文主要介绍java中使用POI生成Excel并导出过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录需求说明及实现方式需求完成通用代码版本1版本2结果展示type参数为atype参数为b总结注：本文章中代码均为
阅读更多...
springboot简单集成Security配置的教程

springboot简单集成Security配置的教程

《springboot简单集成Security配置的教程》：本文主要介绍springboot简单集成Security配置的教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,... 目录集成Security安全框架引入依赖编写配置类WebSecurityConfig（自定义资源权限规则
阅读更多...
Java的IO模型、Netty原理解析

Java的IO模型、Netty原理解析

《Java的IO模型、Netty原理解析》Java的I/O是以流的方式进行数据输入输出的,Java的类库涉及很多领域的IO内容：标准的输入输出,文件的操作、网络上的数据传输流、字符串流、对象流等,这篇... 目录1.什么是IO2.同步与异步、阻塞与非阻塞3.三种IO模型BIO（blocking I/O）NI
阅读更多...
java中反射(Reflection)机制举例详解

java中反射(Reflection)机制举例详解

《java中反射(Reflection)机制举例详解》Java中的反射机制是指Java程序在运行期间可以获取到一个对象的全部信息,：本文主要介绍java中反射(Reflection)机制的相关资料... 目录一、什么是反射？二、反射的用途三、获取Class对象四、Class类型的对象使用场景1五、Class
阅读更多...
SpringBoot中封装Cors自动配置方式

SpringBoot中封装Cors自动配置方式

《SpringBoot中封装Cors自动配置方式》：本文主要介绍SpringBoot中封装Cors自动配置方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录SpringBoot封装Cors自动配置背景实现步骤1. 创建 GlobalCorsProperties
阅读更多...
Spring事务中@Transactional注解不生效的原因分析与解决

Spring事务中@Transactional注解不生效的原因分析与解决

《Spring事务中@Transactional注解不生效的原因分析与解决》在Spring框架中,@Transactional注解是管理数据库事务的核心方式,本文将深入分析事务自调用的底层原理,解释为... 目录1. 引言2. 事务自调用问题重现2.1 示例代码2.2 问题现象3. 为什么事务自调用会失效3
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2