rxjava : flatMap、flatMapIterable、flatMapMaybe、flatMapCompletable、flatMapSingle

最新推荐文章于 2022-02-20 13:52:12 发布
最新推荐文章于 2022-02-20 13:52:12 发布
阅读量2.2k 收藏
点赞数
分类专栏： rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_31057219/article/details/102563576
版权
本文深入解析RxJava中的flatMap操作符，介绍其不同变种及其参数含义，包括mapper、combiner、delayErrors、maxConcurrency等。通过示例代码展示如何使用flatMap处理数据流，实现数据的转换和平铺，特别关注错误处理策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

flatMap

返回一个Observable，它向源ObservableSource和指定的集合ObservableSource发出的一对值发射指定函数的结果，
同时限制对这些ObservableSources的并发预订的最大数量

public final <R> Observable<R> flatMap(
					Function<? super T, ? extends ObservableSource<? extends R>> mapper) {
    return flatMap(mapper, false);
}


public final <R> Observable<R> flatMap(
					Function<? super T, ? extends ObservableSource<? extends R>> mapper, 
					boolean delayErrors) {
    return flatMap(mapper, delayErrors, Integer.MAX_VALUE);
}


//bufferSize() = 128
public final <R> Observable<R> flatMap(
					Function<? super T, ? extends ObservableSource<? extends R>> mapper, 
					boolean delayErrors, 
					int maxConcurrency) {
    return flatMap(mapper, delayErrors, maxConcurrency, bufferSize());	
}


public final <R> Observable<R> flatMap(
					Function<? super T, ? extends ObservableSource<? extends R>> mapper,
			        boolean delayErrors, 
			        int maxConcurrency, 
			        int bufferSize) {


public final <R> Observable<R> flatMap(
        Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper,
        Function<? super Throwable, ? extends ObservableSource<? extends R>> onErrorMapper,
        Callable<? extends ObservableSource<? extends R>> onCompleteSupplier) {


public final <R> Observable<R> flatMap(
        Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper,
        Function<Throwable, ? extends ObservableSource<? extends R>> onErrorMapper,
        Callable<? extends ObservableSource<? extends R>> onCompleteSupplier,
        int maxConcurrency) {


public final <R> Observable<R> flatMap(
		Function<? super T, ? extends ObservableSource<? extends R>> mapper, 
		int maxConcurrency) {
    return flatMap(mapper, false, maxConcurrency, bufferSize());
}


public final <U, R> Observable<R> flatMap(
		Function<? super T, ? extends ObservableSource<? extends U>> mapper,
        BiFunction<? super T, ? super U, ? extends R> resultSelector) {
    return flatMap(mapper, resultSelector, false, bufferSize(), bufferSize());
}


public final <U, R> Observable<R> flatMap(
		Function<? super T, ? extends ObservableSource<? extends U>> mapper,
		BiFunction<? super T, ? super U, ? extends R> combiner, 
		boolean delayErrors) {
    return flatMap(mapper, combiner, delayErrors, bufferSize(), bufferSize());
}


public final <U, R> Observable<R> flatMap(
		Function<? super T, ? extends ObservableSource<? extends U>> mapper,
		BiFunction<? super T, ? super U, ? extends R> combiner, 
		boolean delayErrors, 
		int maxConcurrency) {
    return flatMap(mapper, combiner, delayErrors, maxConcurrency, bufferSize());
}



public final <U, R> Observable<R> flatMap(
		Function<? super T, ? extends ObservableSource<? extends U>> mapper,
        BiFunction<? super T, ? super U, ? extends R> combiner, 
        int maxConcurrency) {
    return flatMap(mapper, combiner, false, maxConcurrency, bufferSize());
}


// mapper (映射器) : 为源ObservableSource发出的每个项目返回ObservableSource的函数
// combiner	(结合): 一个函数，它将源和集合ObservableSources的每一个发出的一项组合在一起，
//				并且返回要由结果ObservableSource发出的一项
// delayErrors (延迟错误): 
//		如果为true，则将当前Observable和所有内部ObservableSource的异常延迟到它们全部终止之前
//	 	如果为false，则第一个发出异常的信号将立即终止整个序列
// maxConcurrency (最大并发): 可以同时订阅的ObservableSources的最大数量
// bufferSize (缓冲区大小): 要从内部ObservableSources中预取的元素数。
public final <U, R> Observable<R> flatMap(
		final Function<? super T, ? extends ObservableSource<? extends U>> mapper,
        final BiFunction<? super T, ? super U, ? extends R> combiner, 
        boolean delayErrors, 
        int maxConcurrency, 
        int bufferSize)

flatMapIterable


public final <U> Observable<U> flatMapIterable(
		final Function<? super T, ? extends Iterable<? extends U>> mapper) 


public final <U, V> Observable<V> flatMapIterable(
		final Function<? super T, ? extends Iterable<? extends U>> mapper,
        BiFunction<? super T, ? super U, ? extends V> resultSelector)

flatMapMaybe

将上游Observable的每个元素映射到MaybeSources中，
订阅所有元素并将它们的onSuccess值以不特定的顺序合并到单个Observable序列中。

public final <R> Observable<R> flatMapMaybe(
		Function<? super T, ? extends MaybeSource<? extends R>> mapper) {
    return flatMapMaybe(mapper, false);
}


//delayErrors ： 延迟错误
public final <R> Observable<R> flatMapMaybe(
		Function<? super T, ? extends MaybeSource<? extends R>> mapper, 
		boolean delayErrors)

flatMapCompletable

将上游Observable的每个元素映射到CompletableSources中，对其进行订阅，
并等待上游和所有CompletableSources完成，从而有选择地延迟所有错误。

public final Completable flatMapCompletable(
		Function<? super T, ? extends CompletableSource> mapper) {
    return flatMapCompletable(mapper, false);
}

//delayErrors ： 延迟错误
public final Completable flatMapCompletable(
		Function<? super T, ? extends CompletableSource> mapper, 
		boolean delayErrors)

flatMapSingle

将上游Observable的每个元素映射到SingleSources中，
并对其进行订阅并将它们的onSuccess值【以不特定顺序】合并到单个Observable序列中，
可以选择延迟所有错误。

public final <R> Observable<R> flatMapSingle(
			Function<? super T, ? extends SingleSource<? extends R>> mapper) {
    return flatMapSingle(mapper, false);
}


//delayErrors ： 延迟错误
public final <R> Observable<R> flatMapSingle(
			Function<? super T, ? extends SingleSource<? extends R>> mapper, 
			boolean delayErrors)

示例

  • flatMap 示例
//正常发射
public void flatMap1() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onComplete();
        }
    }).flatMap(
            new Function<Integer, ObservableSource<Integer>>() {
                /**
                 * @param integer 原始Observable发出的数据
                 */
                @Override
                public ObservableSource<Integer> apply(Integer integer) throws Exception {
                    System.out.println("Function 原始Observable============" + integer);
                    return Observable.just(integer * 100);
                }
            },
            new BiFunction<Integer, Integer, Integer>() {
                /**
                 * @param integer   : 原始Observable发出的数据
                 * @param integer2  : flatmap里Observable发出的的数据
                 */
                @Override
                public Integer apply(Integer integer, Integer integer2) throws Exception {
                    System.out.println("====BiFunction 原始Observable=========" + integer);
                    System.out.println("====BiFunction flatmap里Observable====" + integer2);
                    return integer * integer2;
                }
            },
            true,
            Observable.bufferSize(),
            Observable.bufferSize())
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("=========onSubscribe=========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }

                @Override
                public void onComplete() {
                    System.out.println("=========onComplete=========");
                }
            });
}
//=========onSubscribe=========
//Function 原始Observable============1
//====BiFunction 原始Observable=========1
//====BiFunction flatmap里Observable====100
//========onNext==========100
//Function 原始Observable============2
//====BiFunction 原始Observable=========2
//====BiFunction flatmap里Observable====200
//========onNext==========400
//Function 原始Observable============3
//====BiFunction 原始Observable=========3
//====BiFunction flatmap里Observable====300
//========onNext==========900
//=========onComplete=========



//发射error
public void flatMap2() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onError(new Error("=error="));
            emitter.onNext(3);
            emitter.onComplete();
        }
    }).flatMap(
            new Function<Integer, ObservableSource<Integer>>() {
                /**
                 * @param integer 原始Observable发出的数据
                 */
                @Override
                public ObservableSource<Integer> apply(Integer integer) throws Exception {
                    System.out.println("Function 原始Observable============" + integer);
                    return Observable.just(integer * 100);
                }
            },
            new BiFunction<Integer, Integer, Integer>() {
                /**
                 * @param integer   : 原始Observable发出的数据
                 * @param integer2  : flatmap里Observable发出的的数据
                 */
                @Override
                public Integer apply(Integer integer, Integer integer2) throws Exception {
                    System.out.println("====BiFunction 原始Observable===========" + integer);
                    System.out.println("====BiFunction flatmap里Observable======" + integer2);
                    return integer * integer2;
                }
            },
            true,
            Observable.bufferSize(),
            Observable.bufferSize())
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("=========onSubscribe=========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }

                @Override
                public void onComplete() {
                    System.out.println("=========onComplete=========");
                }
            });
}
//=========onSubscribe=========
//Function 原始Observable============1
//====BiFunction 原始Observable===========1
//====BiFunction flatmap里Observable======100
//========onNext==========100
//Function 原始Observable============2
//====BiFunction 原始Observable===========2
//====BiFunction flatmap里Observable======200
//========onNext==========400
//========onError===========error=
  • flatMapCompletable示例
/**
 * 我们最终只需要知道成功还是失败可以使用flatMapCompletable
 */

//=======================================================================
//  delayErrors = false
//  flatMapCompletable 处理发射的数据并添加onComplete、onError 直接回调结束
//=======================================================================

public void flatMapCompletable1() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onNext(4);
            emitter.onNext(5);
            emitter.onNext(6);
            emitter.onNext(7);
            emitter.onNext(8);
            emitter.onNext(9);
            emitter.onNext(10);
        }
    }).flatMapCompletable(
            new Function<Integer, CompletableSource>() {
                @Override
                public CompletableSource apply(Integer integer) throws Exception {
                    System.out.println("========flatMapCompletable======" + integer);
                    if (integer % 2 == 0) {
                        return Completable.error(new Throwable("-error-"));
                    } else {
                        return Completable.complete();
                    }
                }
            },
            false)
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("========onSubscribe==========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }
            });
}
//========onSubscribe==========
//========flatMapCompletable======1
//========flatMapCompletable======2
//========onError==========-error-

public void flatMapCompletable2() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onNext(4);
            emitter.onNext(5);
            emitter.onNext(6);
            emitter.onError(new Error("-error-"));
            emitter.onNext(7);
            emitter.onNext(8);
            emitter.onNext(9);
            emitter.onNext(10);
        }
    }).flatMapCompletable(
            new Function<Integer, CompletableSource>() {
                @Override
                public CompletableSource apply(Integer integer) throws Exception {
                    System.out.println("========flatMapCompletable======" + integer);
                    if (integer % 2 == 0) {
                        return Completable.error(new Throwable("-error-"));
                    } else {
                        return Completable.complete();
                    }
                }
            },
            false)
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("========onSubscribe==========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }
            });
}
//========onSubscribe==========
//========flatMapCompletable======1
//========flatMapCompletable======2
//========onError==========-error-


public void flatMapCompletable3() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onNext(4);
            emitter.onNext(5);
            emitter.onNext(6);
            emitter.onComplete();
            emitter.onNext(7);
            emitter.onNext(8);
            emitter.onNext(9);
            emitter.onNext(10);
        }
    }).flatMapCompletable(
            new Function<Integer, CompletableSource>() {
                @Override
                public CompletableSource apply(Integer integer) throws Exception {
                    System.out.println("========flatMapCompletable======" + integer);
                    if (integer % 2 == 0) {
                        return Completable.error(new Throwable("-error-"));
                    } else {
                        return Completable.complete();
                    }
                }
            },
            false)
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("========onSubscribe==========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }
            });
}
//========onSubscribe==========
//========flatMapCompletable======1
//========flatMapCompletable======2
//========onError==========-error-

//=======================================================================
//  delayErrors = true
//  flatMapCompletable 处理发射的数据并添加onComplete、onError 
//  但不会结束，直到Observable 发射onComplete、onError 结束
//=======================================================================

public void flatMapCompletable4() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onNext(4);
            emitter.onNext(5);
            emitter.onNext(6);
            emitter.onNext(7);
            emitter.onNext(8);
            emitter.onNext(9);
            emitter.onNext(10);
        }
    }).flatMapCompletable(
            new Function<Integer, CompletableSource>() {
                @Override
                public CompletableSource apply(Integer integer) throws Exception {
                    System.out.println("========flatMapCompletable======" + integer);
                    if (integer % 2 == 0) {
                        return Completable.error(new Throwable("-error-"));
                    } else {
                        return Completable.complete();
                    }
                }
            },
            true)
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("========onSubscribe==========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }
            });
}
//========onSubscribe==========
//========flatMapCompletable======1
//========flatMapCompletable======2
//========flatMapCompletable======3
//========flatMapCompletable======4
//========flatMapCompletable======5
//========flatMapCompletable======6
//========flatMapCompletable======7
//========flatMapCompletable======8
//========flatMapCompletable======9
//========flatMapCompletable======10

public void flatMapCompletable5() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onNext(4);
            emitter.onNext(5);
            emitter.onNext(6);
            emitter.onError(new Error("-error-"));
            emitter.onNext(7);
            emitter.onNext(8);
            emitter.onNext(9);
            emitter.onNext(10);
        }
    }).flatMapCompletable(
            new Function<Integer, CompletableSource>() {
                @Override
                public CompletableSource apply(Integer integer) throws Exception {
                    System.out.println("========flatMapCompletable======" + integer);
                    if (integer % 2 == 0) {
                        return Completable.error(new Throwable("-error-"));
                    } else {
                        return Completable.complete();
                    }
                }
            },
            true)
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("========onSubscribe==========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }
            });
}
//========onSubscribe==========
//========flatMapCompletable======1
//========flatMapCompletable======2
//========flatMapCompletable======3
//========flatMapCompletable======4
//========flatMapCompletable======5
//========flatMapCompletable======6
//========onError==========4 exceptions occurred.


public void flatMapCompletable6() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            emitter.onNext(2);
            emitter.onNext(3);
            emitter.onNext(4);
            emitter.onNext(5);
            emitter.onNext(6);
            emitter.onComplete();
            emitter.onNext(7);
            emitter.onNext(8);
            emitter.onNext(9);
            emitter.onNext(10);
        }
    }).flatMapCompletable(
            new Function<Integer, CompletableSource>() {
                @Override
                public CompletableSource apply(Integer integer) throws Exception {
                    System.out.println("========flatMapCompletable======" + integer);
                    if (integer % 2 == 0) {
                        return Completable.error(new Throwable("-error-"));
                    } else {
                        return Completable.complete();
                    }
                }
            },
            true)
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("========onSubscribe==========");
                }

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

                @Override
                public void onError(Throwable e) {
                    System.out.println("========onError==========" + e.getMessage());
                }
            });
}
//========onSubscribe==========
//========flatMapCompletable======1
//========flatMapCompletable======2
//========flatMapCompletable======3
//========flatMapCompletable======4
//========flatMapCompletable======5
//========flatMapCompletable======6
//========onError==========3 exceptions occurred.
RxJava2 Flowable flatMap 、flatMapIterable、 flatMapMaybe、flatMapSingle 变换操作符
无问西东的博客
10-07 4892
flatMap（变换操作符） 目录 1 flatMap作用和使用场景 2 flatMap接口 3 重点单词 4 flatMap图解和说明 5flatMap测试用例 6flatMapIterable 7flatMapMaybe 8 flatMapSingle 1 flatMap作用和使用场景 这个方法很有用，例如，当你有一个Publisher，其发射项目本身就是Pu...
java中contact方法_RxJava2 转换操作符之ContactMap()和flatMapIterable()
weixin_33514140的博客
02-24 1433
前言：1、学习这两个操作符之前，请确保你读过这篇文章：RxJava2 转换操作符之FlatMap()方法，或者已经充分了解FlatMap()。2、因为这两个操作符，跟FlatMap只有一点不同，所以，将它们独立的，合并在一篇中。一、ContactMap操作符ContactMap是用来解决FlatMap操作符，在转换数据的过程，会出现任务交叉的问题。如果，你对数据转换的过程，要求严格的按顺序执行。即...
RxJava之flatMap系列转换操作符
103style
06-24 1595
转载请以链接形式标明出处： 本文出自:103style的博客 转换相关的操作符 以及 官方介绍 RxJava 之 flatMap 系列 转换操作符 官方介绍 ：Transforming Observables flatMap flatMapCompletable flatMapIterable flatMapMaybe flatMapObservable flatMapPublisher f...
RxJava flatmap
05-12 748
RxJava flatmapflatMap() 中返回的是个 Observable 对象，并且这个 Observable 对象并不是被直接发送到了 Subscriber的回调方法中。 flatMap() 的原理是这样的：1. 使用传入的事件对象创建一个 Observable 对象；2. 并不发送这个 Observable, 而是将它激活，于是它开始发送事件；3. 每一个创建出来的 Observabl
RXJAVA-FlatMap
大新博客
02-22 1113
FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里. package com.netty.demo.vertx; import io.reactivex.*; import io.reactivex.functions.Consumer; import io.reactivex.functions.Function; import io.reactivex.schedulers.Sc.
RxJava flatMap使用
zy6576753的博客
12-14 1212
RxJava flatMap使用 1、使用场景 首先从一个接口中获取list,然后根据获取到list中的元素信息，再获取每个元素的详细信息 2、以下是代码片段（仅笔记于此） String albumUrl = “http://m.kugou.com/zlist/list ?listid=2&amp;type=0&amp;uid=89255811 &amp;sign=495dc043c2b3ac9f...
RxJava 中的map与flatMap
weixin_33713503的博客
07-08 144
1、map和flatMap都是接受一个函数作为参数(Func1) 2、map函数只有一个参数，参数一般是Func1，Func1的&lt;I,O&gt;I,O模版分别为输入和输出值的类型，实现Func1的call方法对I类型进行处理后返回O类型数据 3、flatMap函数也只有一个参数，也是Func1,Func1的&lt;I,O&gt;I,O模版分别为输入和输出值的类型，实现Func1的call方法...
Rxjava(变换类)--FlatMap
new_abc的专栏
10-25 1604
FlatMap 将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并 后放进一个单独的Observable FlatMap 操作符使用一个指定的函数对原始Observable发射的每一项数据执行变换操作，这 个函数返回一个本身也发射数据的Observable，然后 FlatMap 合并这些Observables发射的数 据，最后将合并后
RxJava 操作符flatmap
Dream It Possible
05-24 9595
有如下场景： 在前段调用后端的API时，经常会出现回调嵌套的情况。假设我们有两个API，queryA 和 queryB. 并且queryB的运行依赖于queryA的结果。那么我们的程序在一般的情况下可能是这个样子。 想象有如下的代码: 是不是感觉非常不舒服？假如嵌套的API再多几层，那么这将是个灾难。一个人开发的时候可能不觉得有什么问题，但是可以想象做code review或者新入项目组的同事
Rxjava之flatMap操作符
qq_34015596的博客
01-18 415
flatMap是将Observable发射的数据集合变换为Observables集合，然后将这些发射的数据平坦化地放进一个单独的Observable中。 案例一： 先定义一个用户对象，包含用户名和地址，由于地址可能会包含生活，工作等地方，所以使用一个List对象来表示用户的地址。 public class User { public String userName; ...
RxJava 2.x 源码分析 之 FlatMap
02-20 1150
FlatMap 官方定义：把被观察者发射出去的事件转化成新的子被观察者，然后把这些发射量展开平铺后统一放到一个被观察者中。官方文档 简单来讲就是把被观察者每次发射的事件转化成一个子被观察者，然后通过合并(Merge)所有子被观察者的事件成总的一系列的事件并发射给观察者。 官方文档中提及到很多语言都拥有 Merge 和 Concat 的合并操作，他们的区别是前者会顺序交错，而后者是不会破坏顺序的。 所以FlatMap和ConcatMap的区别是合并后的事件顺序有可能是无.
rxjava : Completable # andThen 对比 Observable # flatMapCompletable
火星男孩的分享空间
10-17 1142
Completable # andThen : //返回一个新的Completable C，它首先运行此Completable A，然后再运行另一个Completable B。 //A / B 没有数据关系，只有执行顺序关系和是否执行关系 //A 先执行 ， B 后执行 //A onError报错不执行B , A onComplete 才执行B public final Completable ...
学习 RxJava <三>flatMap
weixin_30690833的博客
07-30 130
出于安全性、性能等方面的考虑，多数服务器会有一些接口需要传入 token 才能正确返回结果，而 token 是需要从另一个接口获取的，这就需要使用两步连续的请求才能获取数据（①token -> ②目标数据）。 使用 flatMap() 可以用较为清晰的代码实现这种连续请求，避免 Callback 嵌套的结构。代码大致形式 api.getToken().flatMap(token -&...
RxJava 源码解读分析 flatMap
冰冻火山
05-09 680
这一节，我们重点来分析RxJava.flatMap()方法内部是如何实现的 先上一段测试代码，如下所示： @Test public void test2() throws InterruptedException { Observable.create(new Observable.OnSubscribe() { @Override
Rxjava(变换类)--FlatMap2
new_abc的专栏
10-26 952
demo ArrayList aa= new ArrayList<>(Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9, 10)); Observable.from(aa).flatMap(new Func1>() { @Override public Observable call(Int
rxjava2.0第三篇之flatMap使用
mwthe的博客
09-19 2176
flatMap 方法： public final &lt;R&gt; Observable&lt;R&gt; flatMap(Function&lt;? super T, ? extends ObservableSource&lt;? extends R&gt;&gt; mapper) { return flatMap(mapper, false); } flat...
RxJava1.0 flatMap方法的源码分析
sinat_32955803的博客
07-16 1277
RxJava1.0 flatMap方法的源码分析 package com.yue.test; import java.awt.Cursor; import java.util.ArrayList; import java.util.List; import com.yue.bean.Course; import com.yue.bean.Student; import rx.O
RxJava（三） flatMap 操作符用法详解
热门推荐
Chiclaim
05-29 5万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
RxJava flatMap操作符用法详解
michael1112的专栏
09-20 941
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作
掌握RxJava: BehaviorSubject的应用和代码示例
RxJava 是一个在 Java VM 上使用可观测的序列来编写异步和基于事件的程序的库。它将事件序列的概念抽象成了 Observable 类，使用观察者模式。RxJava 由 Netflix 开源，并且现在已经成为了响应式编程在 Java 中的事实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值