RxJava2.0中fromArray操作符用法和源码分析（三）

最新推荐文章于 2024-08-14 20:41:41 发布
最新推荐文章于 2024-08-14 20:41:41 发布
阅读量8.6k 收藏
点赞数 1
分类专栏： RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuminfeng728/article/details/77494034
版权
fromArray基本使用

fromArray用来创建一个Observable对象，可以将一个数组转化为可被观察的序列并且将它的数据逐个发射。
image
fromArray与just相似，都可以用来发射单个或一组数据，但是区别是当fromArray发射一组数据到观察序列中来时，它会先进行遍历，然后再逐个发射。而just发射一组数据时，会把它当成一个整体，一次性发射。字面意思难以理解，我们用代码说明：

Integer[] items = { 0, 1, 2, 3, 4, 5 };

Observable.fromArray(items).subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        println("onNext : fromArray : " + integer + "\n");
    }
});

Observable.just(items).subscribe(new Consumer<Integer[]>() {
    @Override
    public void accept(Integer[] integers) throws Exception {
        for (int i: integers) {
            println("onNext : just : " + i + "\n");
        }
    }
});

输出结果：

onNext : fromArray : 0
onNext : fromArray : 1
onNext : fromArray : 2
onNext : fromArray : 3
onNext : fromArray : 4
onNext : fromArray : 5

onNext : just : 0
onNext : just : 1
onNext : just : 2
onNext : just : 3
onNext : just : 4
onNext : just : 5

上面输出结果是不一样的，使用fromArray时，接收的数据是逐个打印出来，而使用just时，直接接收的是一个数组。所以如上面所说fromArray接收的数据源是逐个发射的，而just是将数据作为一个完整的对象一次性发射的。

下面我们将继续从源码的角度进行分析：
老规矩我们还是从fromArray方法中着手分析：
Observable#fromArray

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> fromArray(T... items) {
    ObjectHelper.requireNonNull(items, "items is null");
    if (items.length == 0) {
        return empty();
    } else
    if (items.length == 1) {
        return just(items[0]);
    }
    return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
}

fromArray方法接收的是一个可变参数，该参数又作为创建ObservableFromArray对象的参数。最后返回的是ObservableFromArray对象，作为Observable的具体实现类。

然后开始订阅观察者对象，这里我使用Consumer作为观察者。继续查看subscribe方法：
Observable#subscribe

......

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
        Action onComplete, Consumer<? super Disposable> onSubscribe) {
    ObjectHelper.requireNonNull(onNext, "onNext is null");
    ObjectHelper.requireNonNull(onError, "onError is null");
    ObjectHelper.requireNonNull(onComplete, "onComplete is null");
    ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");

    LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);

    subscribe(ls);

    return ls;
}

@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}

这里其实和just操作符调用的逻辑一样，都是重载的subscribe方法，最后执行的是接收四个参数的subscribe方法，如上。这里的创建LambdaObserver对象，不再做重复说明。
subscribeActual其实调用的是Observable实现类中的方法，也就是ObservableFromArray中的方法。我们直接进入该类中查看：
ObservableFromArray

public final class ObservableFromArray<T> extends Observable<T> {
    final T[] array;
    public ObservableFromArray(T[] array) {
        this.array = array;
    }
    @Override
    public void subscribeActual(Observer<? super T> s) {
        FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array);

        s.onSubscribe(d);

        if (d.fusionMode) {
            return;
        }

        d.run();
    }

    ......
}

subscribeActual中，创建了一个FromArrayDisposable类对象，执行了Observer中的onSubscribe方法，也就是LambdaObserver中的onSubscribe方法。我们在进入这个方法中看一下：

LambdaObserver#onSubscribe


public LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
        Action onComplete,
        Consumer<? super Disposable> onSubscribe) {
    super();
    this.onNext = onNext;
    this.onError = onError;
    this.onComplete = onComplete;
    this.onSubscribe = onSubscribe;
}

@Override
public void onSubscribe(Disposable s) {
    if (DisposableHelper.setOnce(this, s)) {
        try {
            onSubscribe.accept(this);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            s.dispose();
            onError(ex);
        }
    }
}

通过第四个参数 onSubscribe的接口回调方法，将FromArrayDisposable对象暴露给外部调用。这里也不再说明。
我们重点来看看FromArrayDisposable中的run方法：

FromArrayDisposable#run

void run() {
    T[] a = array;
    int n = a.length;

    for (int i = 0; i < n && !isDisposed(); i++) {
        T value = a[i];
        if (value == null) {
            actual.onError(new NullPointerException("The " + i + "th element is null"));
            return;
        }
        actual.onNext(value);
    }
    if (!isDisposed()) {
        actual.onComplete();
    }
}

array 代表我们刚才传入的数组的对象。在for循环中对数组进行遍历，然后将数组中的值据逐个通过actual.onNext(value)方法发送出去。如果出现错误时，则调用actual.onError。完成发送后，在调用actual.onComplete()方法。而我们知道这里面分别调用的是LambdaObserver对象中的方法。

public final class LambdaObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {

    private static final long serialVersionUID = -7251123623727029452L;
    final Consumer<? super T> onNext;
    final Consumer<? super Throwable> onError;
    final Action onComplete;
    final Consumer<? super Disposable> onSubscribe;

    public LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete,
            Consumer<? super Disposable> onSubscribe) {
        super();
        this.onNext = onNext;
        this.onError = onError;
        this.onComplete = onComplete;
        this.onSubscribe = onSubscribe;
    }

    @Override
    public void onSubscribe(Disposable s) {
        if (DisposableHelper.setOnce(this, s)) {
            try {
                onSubscribe.accept(this);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                s.dispose();
                onError(ex);
            }
        }
    }

    @Override
    public void onNext(T t) {
        if (!isDisposed()) {
            try {
                onNext.accept(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                get().dispose();
                onError(e);
            }
        }
    }

    @Override
    public void onError(Throwable t) {
        if (!isDisposed()) {
            lazySet(DisposableHelper.DISPOSED);
            try {
                onError.accept(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                RxJavaPlugins.onError(new CompositeException(t, e));
            }
        }
    }

    @Override
    public void onComplete() {
        if (!isDisposed()) {
            lazySet(DisposableHelper.DISPOSED);
            try {
                onComplete.run();
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                RxJavaPlugins.onError(e);
            }
        }
    }

    @Override
    public void dispose() {
        DisposableHelper.dispose(this);
    }

    @Override
    public boolean isDisposed() {
        return get() == DisposableHelper.DISPOSED;
    }
}

如上，在LambdaObserver类中onNext，onError，onComplete分别对应的不同的参数回调，从而将接口中的数据传递给外部。这样便完成了调用。

下面列出fromArray和just操作符的简单demo：

List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");

Observable.fromArray(list).subscribe(new Consumer<List<String>>() {
    @Override
    public void accept(List<String> strings) throws Exception {
        println("onNext : fromArray : " + strings + "\n");
    }
});

Observable.just(list).subscribe(new Consumer<List<String>>() {
    @Override
    public void accept(List<String> strings) throws Exception {
        println("onNext : just : " + strings + "\n");
    }
});

输出结果：

onNext : fromArray : [hello, world]

onNext : just : [hello, world]
yuminfeng728
关注
专栏目录
RxJava2源码分析二之just、fromArray、fromIterable
林序的博客
08-24 3657
     Observable.just：接收1个以上,10个以下的参数，然后逐个发射。         Observable.fromArray：接收一个数组，从数组中一个一个取出来发射。        今天从源码来看一下Observable的just方法和FromArray。        public static &lt;T&gt; Observable&lt;T&gt; jus...
RxJava2.0操作符详解
qq_43093708的博客
03-06 577
Rxjava2.0概述 通过前面的文章介绍，读者对RxJava2.0应该有了初步的认识。RxJava2.0相对1.0没有增加新的功能，最大的变化是把原来与背压有关的操作符抽取出来放在Flowable中处理；另外2.0的接口定义更符合ReactiveStream的规范。操作符的功能和1.0相比没有太大的变化，不过Flowable是背压相关的功能抽离出来的，本篇我们来详细分析下各种操作符的作用和用法...
RxJava 学习笔记 2 - from(array)
qq_34224268的博客
07-02 1395
fun start() { //解析 from - 多个 OnSubscribe(订阅回调) Observable.from(arrayOf(1, 2, 3, 4, 5)).subscribe { print(it) } /* 中心思想： 使用多态扩展了 OnSubscribe.call() 使其对 subscribe 的调用形式发生变化。 最终实现多次调用 ...
【js】Array.from方法介绍与用法示例
最新发布
m0_74574927的博客
08-14 316
Array.from是ES6（ECMAScript 2015）中引入的一个静态方法。该方法接受三个参数，并返回一个新的数组实例。
【RxJava】RxJava系列文章之just+fromArray操作符
珍心
10-28 314
学而不思则罔，思而不学则殆 【RxJava】RxJava系列文章之just+fromArray操作符简单介绍简单使用Demo1Demo2Demo3原理分析ObservableEmptyObservableEmpty 源码分析ObservableEmpty 官方的图ObservableEmpty 时序图ObservableJustObservableJust 源码解析ObservableJust 官方用图ObservableJust 时序图ObservableFromArrayObservableFromAr
二、RxJava 创建：create，just，fromArray，empty，range
sunweihao2019的博客
11-24 317
1.项目地址 在MainActivity3那里 2.讲解 1.普通创建 create：这里发射一个“A”，然后打印出来： //普通创建： Observable.create(new ObservableOnSubscribe<String>() { @Override public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Thro
RxJava2总结之操作详解(一)
狂健小夫的博客
08-17 5185
目录目录 创建操作 create just empty never error timer range intervalRange interval defer from系列 fromArray fromCallable fromIterable fromFuture 过滤操作 elementAt IgnoreElements take系列 take takeLast takeUntil takeW
RxJava2.0在android开发中的实用操作符总结
04-14
本文将深入探讨RxJava2.0的一些实用操作符，帮助开发者更好地理解和运用这个强大的工具。 1. **创建Observable** - `just()`: 用于从单个或多个值创建Observable。 - `fromArray()`: 将数组转换为Observable，...
基于RxJava2.0的任务队列
12-11
2. 使用`fromArray()`或`fromIterable()`将任务列表转换为Observable序列。 3. 使用`concat()`或`concatMap()`操作符设置任务执行顺序。 4. 使用`subscribeOn(Schedulers.io())`指定任务在哪个线程执行，通常选择IO...
Rxjava(三)、操作符的使用
Evan的博客
04-02 516
Android进阶系列之第三方库知识点整理。 知识点总结，整理也是学习的过程，如有错误，欢迎批评指出。 第一篇：Rxjava2(一)、基础概念及使用 第二篇：Rxjava2(二)、五种观察者模式及背压 终于到操作符了，我觉得rxjava2如此好用，绝对少不了操作符的功劳，下面这张图你就简单的扫一眼，别慌，我们慢慢啃。 上一篇讲了，rxjava有五种观察者创建模式，其中Observable和F...
RxJava 操作符 图片
03-31
通过结合实际案例和操作符图片，你可以更有效地掌握 RxJava 的精髓，并将其应用于 Android 开发或者其他需要处理异步数据流的场景。 总结一下，RxJava 操作符是构建复杂异步逻辑的基石，它们提供了强大的工具来处理...
PIL image.fromarray()函数
Dontla的博客
01-11 1万+
def fromarray(obj, mode=None): """ Creates an image memory from an object exporting the array interface (using the buffer protocol). 从导出阵列接口的对象创建图像存储器 （使用缓冲协议）。 If **obj** is not contiguous, then the tobytes method is called a
Image.fromarray的用法
qq_44976409的博客
05-28 4503
Image.fromarray的用法 https://blog.csdn.net/weixin_43593330/article/details/106708364
Image.fromarray的用法（实现array到image的转换）
热门推荐
我是天才很好
06-12 3万+
一、Image.fromarray的作用： 简而言之，就是实现array到image的转换。 二、PIL中的Image和numpy中的数组array相互转换： 1. PIL image转换成array img = np.asarray(image) 需要注意的是，如果出现read-only错误，并不是转换的错误，一般是你读取的图片的时候，默认选择的是"r","rb"模式有关。 修正的办法:　手动修改图片的读取状态 img.flags.writeable = True # 将数组改为读写模式` 2. a
rxjava2操作符
weixin_39877109的博客
12-09 133
rxjava2操作符 1. 创建操作符 create() 创建一个被观察者 public static <T> Observable<T> create(ObservableOnSubscribe<T> source) just() 创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。 public static <T> Observable<T> just(T item) ...... public static <T>
fromarray()方法-源码剖析
weixin_57234928的博客
12-10 303
fromarray()方法-源码剖析
RxJava2 基础教程（一）HelloWorld
forJrking的博客
02-05 2698
RxJava2基础使用初学者引导，已经学习过RxJava的可跳过响应式编程主要目的是方便我们对复杂需求的编程的一种简化思想（个人理解），例如 Android中的异步任务，主线程更新UI操作，Event 总线等等。先从理解和使用 java 的 观察者模式 开始入手，java提供一个类 java.util.Observable（敌方） 和 接口 Observer（侦察兵）定义一个类 AObserver
关于RxJava的from()和 flatMap()方法
蓝冷然的博客
04-08 362
关于RxJava的from()和 flatMap()方法 最近自己在学RxJava ，想到了一个东西，所以就在这里写下来。 首先是from()方法，他可以接收一个集合，然后将其中的子元素挨个拆出来，例如下面的代码： myObservable.just(mList).subscribe(new Action1&lt;List&lt;Str...
深入解析Android开发中的RxJava操作符应用
资源摘要信息:"Android + Rxjava + Rxjava操作符" 1. RxJava简介 ...该文件通常包含了完整的示例代码，涵盖了RxJava操作符的使用方法和最佳实践，是学习和深入理解RxJava在Android上应用的重要资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值