WranglerxJava 基础操作符的行使入门(创造操作)彩

2019-09-18 21:56 来源:未知

代码:

1.5 Interval

创建一个按照给定的时间间隔发射整数序列的 Observable。

彩民之家论坛9066777 1

interval

示例代码:

final CompositeDisposable disposable = new CompositeDisposable();
disposable.add(Observable.interval(1, TimeUnit.SECONDS).subscribeWith(new DisposableObserver<Long>() {
    @Override
    public void onNext(@NonNull Long aLong) {
        System.out.println("Next: "   aLong);
    }

    @Override
    public void onError(@NonNull Throwable error) {
        System.err.println("Error: "   error.getMessage());
    }

    @Override
    public void onComplete() {
        System.out.println("onComplete");
    }
}));
//5秒后取消订阅
try {
    Thread.sleep(4000);
    //取消订阅
    disposable.dispose();
} catch (InterruptedException e) {
    e.printStackTrace();
}

输出结果:

Next: 0
Next: 1
Next: 2
Next: 3

Create

使用一个函数从头开始创建一个Observable,并设置一个接受观察者函数作为参数,并让其恰当的调用观察者的onNext,onError,onCompeleted方法。
(ps:建议你在传递给create方法的函数中检查观察者的isUnsubscribed状态,以便在没有观察者的时候,让其停止发射数据或者做昂贵的运算。)

public static void  create() {
        Observable.create(new OnSubscribe<Integer>() {  //这里泛型所指的参数既为发射数据的类型

            @Override
            public void call(Subscriber<? super Integer> observer) {
                try {
                    if (observer.isUnsubscribed()) { //
                    for (int i = 0; i < 3; i  ) {
                            observer.onNext(i);  //发射数据给观察者
                        }
                    }
                    observer.onCompleted(); //发射完毕
                } catch (Exception e) {
                    observer.onError(e);  //发射出错
                }

            }
        }).subscribe(new Observer<Integer>() {

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

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

            @Override
            public void onNext(Integer t) {
                System.out.println("onNext : "   t);
            }
        }); 
    }
}
03-18 00:24:50.660 28474-28474/com.io.github.hjianfei.demo D/onResponse: Repeat操作符103-18 00:24:50.661 28474-28474/com.io.github.hjianfei.demo D/onResponse: Repeat操作符203-18 00:24:50.661 28474-28474/com.io.github.hjianfei.demo D/onResponse: Repeat操作符303-18 00:24:50.665 28474-28474/com.io.github.hjianfei.demo D/onResponse: Repeat操作符103-18 00:24:50.665 28474-28474/com.io.github.hjianfei.demo D/onResponse: Repeat操作符203-18 00:24:50.665 28474-28474/com.io.github.hjianfei.demo D/onResponse: Repeat操作符303-18 00:24:50.665 28474-28474/com.io.github.hjianfei.demo D/onResponse: onCompleted

1.8 Repeat

创建一个重复发射指定数据或数据序列的 Observable。

彩民之家论坛9066777 2

repeat

示例代码:

//重复三次,repeat()就是无限次
Observable.just("hello", "world").repeat(3).subscribe(new Observer<Object>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(@NonNull Object o) {
        System.out.println("onNext:"   o.toString());
    }

    @Override
    public void onError(@NonNull Throwable error) {
        System.err.println("Error: "   error.getMessage());
    }

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

输出结果:

onNext:hello
onNext:world
onNext:hello
onNext:world
onNext:hello
onNext:world
onComplete

创建操作

真可惜简书不支持锚点
这篇文章只是介绍操作符中的创建操作,其实创建操作包括了一些其他方面知识,比如调度器,我们会在后面的文章中讲解。

  • Create
  • Defer
  • Empty/Never/Throw(不做介绍,很少用,一般用作测试)
  • From
  • Interval
  • Just
  • Range
  • Repeat
  • Timer

结果:

RxJava2.0 操作符(1)—— Create 创建操作

Create 创建类操作符

Create — 使用一个函数从头创建一个 Observable。
Defer — 只有当订阅者订阅才创建 Observable;为每个订阅创建一个新的 Observable。
Empty — 创建一个什么都不做直接通知完成的 Observable。
Error — 创建一个什么都不做直接通知错误的 Observable。
From — 将一个 Iterable, 一个 Future, 或者一个数组转换成一个 Observable。
Interval — 创建一个按照给定的时间间隔发射整数序列的 Observable。
Just — 将一个或多个对象转换成发射这个或这些对象的一个 Observable。
Range — 创建一个发射指定范围的整数序列的 Observable。
Repeat — 创建一个重复发射指定数据或数据序列的 Observable。
RepeatWhen — 创建一个重复发射指定数据或数据序列的 Observable,它依赖于另一个 Observable 发射的数据。
Never — 创建一个不发射任何数据的 Observable。
Timer — 创建一个在给定的延时之后发射单个数据的 Observable。

Just

Just类似于From,但是From会将数组取出然后逐个发射,而Just只是简单的原样发射。

    Observable.just("hello","world")
                    .observeOn(Schedulers.immediate())
                    .subscribe(new Action1<String>() {

                        @Override
                        public void call(String t) {
                            // TODO Auto-generated method stub
                            System.out.println(Thread.currentThread().getName());
                            System.out.println(t);
                        }
                    });

彩民之家论坛9066777 3Just操作符

1.7 Range

创建一个发射指定范围的整数序列的 Observable。
RxJava 将这个操作符实现为 range 函数,它接受两个参数,一个是范围的起始值,一个是范围的数据的数目。如果你将第二个参数设为 0,将导致 Observable 不发射任何数据(如果设置为负数,会抛异常)

彩民之家论坛9066777 4

range

示例代码:

// 依次发射 10、11、12
Observable.range(10, 2).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(@NonNull Integer s) {
        System.out.println("Next: "   s);
    }

    @Override
    public void onError(@NonNull Throwable error) {
        System.err.println("Error: "   error.getMessage());
    }

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

输出结果:

Next: 10
Next: 11
Next: 12
onComplete

2、Awesome RxJava

03-18 00:19:55.669 22020-22020/com.io.github.hjianfei.demo D/onResponse: 103-18 00:19:55.669 22020-22020/com.io.github.hjianfei.demo D/onResponse: 203-18 00:19:55.669 22020-22020/com.io.github.hjianfei.demo D/onResponse: 303-18 00:19:55.669 22020-22020/com.io.github.hjianfei.demo D/onResponse: 403-18 00:19:55.669 22020-22020/com.io.github.hjianfei.demo D/onResponse: 503-18 00:19:55.669 22020-22020/com.io.github.hjianfei.demo D/onResponse: onCompleted

1.10 Never

创建一个不发射任何数据的 Observable。

彩民之家论坛9066777 5

never

(ps:不太懂有何意义)

From

from操作可以转换Future、Iterable和数组。对于Iterable和数组,产生的Observable会发射Iterable或者数组的每一项数据。

将create操作符中的示例代码用from操作符写出来

public static void from() {
        Integer[] ints = {1,2,3};
        Observable.from(ints)
                    .subscribe(new Observer<Integer>() {
                        @Override
                         public void onCompleted() {
                            System.out.println("onCompleted");
                        }
                        @Override
                        public void onError(Throwable e) {
                            System.out.println("onError :"   e.getMessage());
                        }
                        @Override
                        public void onNext(Integer t) {
                            System.out.println("onNext : "   t);
                        }
                    });
    }

这种方法简单,但是不能判断出是否观察者取消了订阅,可能会造成浪费。

RxJava将这个操作符实现为repeat方法。它不是创建一个Observable,而是重复发射原始Observable的数据序列,这个序列或者是无限的,或者通过repeat指定重复次数。

1.1 Create

使用一个函数从头创建一个 Observable。

彩民之家论坛9066777 6

rxjava_create

示例代码:

 Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
        for (int i = 1; i < 5; i  ) {
            emitter.onNext(i "");
        }
        emitter.onComplete();
    }
}).subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(@NonNull String s) {
        System.out.println("Next: "   s);
    }

    @Override
    public void onError(@NonNull Throwable error) {
        System.err.println("Error: "   error.getMessage());
    }

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

输出:

Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

1、Reactive ——强烈推荐,Rx官网

结果:

1.4 From

将一个 Iterable, 一个 Future, 或者一个数组转换成一个 Observable。

彩民之家论坛9066777 7

from

示例代码1:

//1.遍历集合
List<String> items = new ArrayList<>();
for (int i = 0; i < 3; i  ) {
    items.add(i   "");
}
Observable<String> observable = Observable.fromIterable(items);
//Observable<String> observable = Observable.fromArray(new String[]{"Hello", "world"});
observable.subscribe(new Consumer<String>() {
    @Override
    public void accept(@NonNull String s) throws Exception {
         System.out.println("result:"   s);
    }
});

输出结果:

result:0
result:1
result:2

Interval

创建一个按固定时间间隔发射整数序列的Observable。

    public static void interval() {
        Observable.interval(1000,TimeUnit.MILLISECONDS,Schedulers.immediate())
                    .subscribe(new Action1<Long>() {
                        @Override
                        public void call(Long value) {
                            // TODO Auto-generated method stub
                            System.out.println("interval value : "   value);
                        }
                    });
    }

Just将单个数据转换为发射那个数据的Observable。

1.6 Just

将一个或多个对象转换成发射这个或这些对象的一个 Observable。

彩民之家论坛9066777 8

just

示例代码:

Observable.just(1, 2, 3).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(@NonNull Integer s) {
        System.out.println("Next: "   s);
    }

    @Override
    public void onError(@NonNull Throwable error) {
        System.err.println("Error: "   error.getMessage());
    }

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

输出结果:

Next: 1
Next: 2
Next: 3
onComplete

我的学习资料

03-18 00:16:30.458 16301-16301/com.io.github.hjianfei.demo D/onResponse: Just操作符103-18 00:16:30.458 16301-16301/com.io.github.hjianfei.demo D/onResponse: Just操作符203-18 00:16:30.458 16301-16301/com.io.github.hjianfei.demo D/onResponse: Just操作符303-18 00:16:30.458 16301-16301/com.io.github.hjianfei.demo D/onResponse: Just操作符403-18 00:16:30.458 16301-16301/com.io.github.hjianfei.demo D/onResponse: onCompleted

1.2 defer

只有当订阅者订阅才创建 Observable;才会为每个订阅创建一个新的 Observable。

彩民之家论坛9066777 9

defer

示例代码:

Observable<String> observable = Observable.defer(new Callable<ObservableSource<? extends String>>() {
        @Override
        public ObservableSource<? extends String> call() throws Exception {
            return Observable.just("String");
        }
    });
    observable.subscribe(new Consumer<String>() {
        @Override
        public void accept(@NonNull String s) throws Exception {
            System.out.println(s);
        }
    });

输出:

String

从2015年10月份知道RxJava并使用过一次之后,因为工作忙的原因一直没有再去接触过这个让人无法抗拒的编程接口。经过几天的学习之后把学习的东西总结一下,毕竟才接触,若有不对的地方,请留言指正。

String from[] = {"From操作符1", "From操作符2", "From操作符3", "From操作符4"}; Observable.from .subscribe(new Subscriber<String>() { @Override public void onCompleted() { Log.d(TAG, "onCompleted"); } @Override public void onError(Throwable e) { Log.d(TAG, "onError:"   e.toString; } @Override public void onNext { Log.d; } });

1.3 Error

创建一个什么都不做直接通知错误的 Observable。

彩民之家论坛9066777 10

throw

示例代码:

 Observable<String> observable = Observable.error(new Callable<Throwable>() {
    @Override
    public Throwable call() throws Exception {
        return new NullPointerException();
    }
});
observable.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(@NonNull String s) {
        System.out.println("Next: "   s);
    }

    @Override
    public void onError(@NonNull Throwable error) {
        System.err.println("Error: "   error.getMessage());
    }

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

输出结果:

Error: null

Range

发射一个范围类有序的整数序列,你可以指定范围的起始和长度

        Observable.range(0, 10)
                    .subscribe(new Action1<Integer>() {

                        @Override
                        public void call(Integer t) {
                            // TODO Auto-generated method stub
                            System.out.println(t);
                        }
                    });

代码:

1.3 Empty

创建一个什么都不做直接通知完成的 Observable。

彩民之家论坛9066777 11

WranglerxJava 基础操作符的行使入门(创造操作)彩民之家论坛9066777。empty

示例代码:

 Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
        for (int i = 1; i < 5; i  ) {
            emitter.onNext(i "");
        }
        emitter.onComplete();
    }
}).subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(@NonNull String s) {
        System.out.println("Next: "   s);
    }

    @Override
    public void onError(@NonNull Throwable error) {
        System.err.println("Error: "   error.getMessage());
    }

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

输出结果:

onComplete

Defer

直到有观察者订阅时才创建Observable,并且为每个观察者创建一个新的Observable。也就是说,只要有观察者订阅了它,就将其包含的数据全部发送给观察者。

在这里我先补充一点,观察者订阅有很多种形式存在,我们可以查看subscribe的API

  public final Subscription subscribe(final Action1<? super T> onNext) {
     ...
    return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
    }

 public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError) {
        ...
        return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
    }

  public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onCompleted) {
       ...
        return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
    }

以上三种都是根据情况来设置相应参数,比如我只用处理发送过来的数据,其他的都不管,就可以使用第一个方法,以此类推。

    public final Subscription subscribe(final Observer<? super T> observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber<? super T>)observer);
        }
        if (observer == null) {
            throw new NullPointerException("observer is null");
        }
        return subscribe(new ObserverSubscriber<T>(observer));
    }

 public final Subscription subscribe(Subscriber<? super T> subscriber) {
        return Observable.subscribe(subscriber, this);
    }

这二个种方法比较特殊。以上方法其实最后调用的都是

Observable.subscribe(subscriber, this)

总而言之就是将订阅者和被观察者绑定起来。
说了这么多,我们看下defer的用法:

public static void defer() {
        Observable<String> defer = Observable.defer(new Func0<Observable<String>>() {

            @Override
            public Observable<String> call() {
                return Observable.just("1","2","3") ; 
            }
        });
        Action1<String> observer1 = new Action1<String>() {
            @Override
            public void call(String t) {
                System.out.println("observer1 onNext :"   t);
            }
        };

        defer.subscribe(observer1);
        Subscriber<String> observer2 = new Subscriber<String>() {

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

            @Override
            public void onNext(String t) {

                System.out.println("observer2 onNext :"   t);
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onCompleted() {

                System.out.println("observer2 onCompleted :");
            }
        };
        defer.subscribe(observer2);
    }

第一次使用简书的编辑功能,发现太多的MarkDown功能都不支持。
在这个例子中,使用了Action和Subscribe作为参数绑定被观察者,而且defer方法中返回的是一个Observable对象,刚好和我们之前讲的会为每个观察者创建一个新的Observable。这个Observable再将数据发射给观察者。

输出结果:

observer1 onNext :1
observer1 onNext :2
observer1 onNext :3
onStart
observer2 onNext :1
observer2 onNext :2
observer2 onNext :3
observer2 onCompleted 
03-18 00:02:39.591 28131-28131/com.io.github.hjianfei.demo D/onResponse: From操作符103-18 00:02:39.591 28131-28131/com.io.github.hjianfei.demo D/onResponse: From操作符203-18 00:02:39.591 28131-28131/com.io.github.hjianfei.demo D/onResponse: From操作符303-18 00:02:39.591 28131-28131/com.io.github.hjianfei.demo D/onResponse: From操作符403-18 00:02:39.591 28131-28131/com.io.github.hjianfei.demo D/onResponse: onCompleted

1.11 Timer

创建一个在给定的延时之后发射单个数据的 Observable。
在 RxJava 1.0.0 及其之后的版本,官方已不再提倡使用 timer() 操作符,因为 interval() 具有同样的功能。

彩民之家论坛9066777 12

timer

示例代码:

Observable.timer(1, TimeUnit.SECONDS)
    .subscribe(new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long aLong) throws Exception {
            System.out.println("result:"   aLong);
        }
    });

输出结果:

result:0

Timer

创建一个Observable,它在一个给定的延迟会发射一个特殊的值(0)

Observable.timer(5, TimeUnit.SECONDS)
                    .subscribe(new Action1<Long>() {

                        @Override
                        public void call(Long t) {
                                System.out.println("hello world!");
                        }
                    });
 Observable.just("Repeat操作符1", "Repeat操作符2", "Repeat操作符3") .repeat .subscribe(new Subscriber<String>() { @Override public void onCompleted() { Log.d(TAG, "onCompleted"); } @Override public void onError(Throwable e) { Log.d(TAG, "onError:"   e.toString; } @Override public void onNext(String just) { Log.d(TAG, just); } });

1.9 RepeatWhen

创建一个重复发射指定数据或数据序列的 Observable,它依赖于另一个 Observable 发射的数据。

Repeat

        Observable.just("1","2")
        .repeat(3)
        .subscribe(new Observer<String>() {

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

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

            @Override
            public void onNext(String t) {
                System.out.println(t   "  "   Thread.currentThread().getName());
            }
        });

Interval操作符返回一个Observable,它按固定的时间间隔发射一个无限递增的整数序列。它接受一个表示时间间隔的参数和一个表示时间单位的参数。

Observable.create(new Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { if (!subscriber.isUnsubscribed {//判断观察者的状态,如果没有订阅则不发送数据 subscriber.onNext("created 操作符1"); subscriber.onNext("created 操作符2"); subscriber.onNext("created 操作符3"); subscriber.onNext("created 操作符4"); subscriber.onCompleted.subscribe(new Subscriber<String>() { @Override public void onCompleted() { Log.d(TAG, "onCompleted"); } @Override public void onError(Throwable e) { Log.d(TAG, "onError:"   e.toString; } @Override public void onNext { Log.d; } });
 Observable.just("Just操作符1", "Just操作符2", "Just操作符3", "Just操作符4") .subscribe(new Subscriber<String>() { @Override public void onCompleted() { Log.d(TAG, "onCompleted"); } @Override public void onError(Throwable e) { Log.d(TAG, "onError:"   e.toString; } @Override public void onNext(String just) { Log.d(TAG, just); } });
interval(long,TimeUnit))interval(long,TimeUnit,Scheduler))
03-18 00:08:58.024 6346-6651/com.io.github.hjianfei.demo D/onResponse: 003-18 00:09:03.023 6346-6651/com.io.github.hjianfei.demo D/onResponse: 103-18 00:09:08.024 6346-6651/com.io.github.hjianfei.demo D/onResponse: 203-18 00:09:13.024 6346-6651/com.io.github.hjianfei.demo D/onResponse: 303-18 00:09:18.024 6346-6651/com.io.github.hjianfei.demo D/onResponse: 403-18 00:09:23.025 6346-6651/com.io.github.hjianfei.demo D/onResponse: 5............

RxJava将这个操作符实现为timer函数。

彩民之家论坛9066777 13From操作符

Timer操作符创建一个在给定的时间段之后返回一个特殊值的Observable。

结果:

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

还有更多的操作符请查看 RXJava官方文档

WranglerxJava 基础操作符的行使入门(创造操作)彩民之家论坛9066777。代码:

结果:

彩民之家论坛9066777 14Create操作符

输出结果:

结果:

彩民之家论坛9066777 15Range操作符

代码:

代码:

Observable.interval(5, TimeUnit.SECONDS) .subscribe(new Subscriber<Long>() { @Override public void onCompleted() { Log.d(TAG, "onCompleted"); } @Override public void onError(Throwable e) { Log.d(TAG, "onError:"   e.toString; } @Override public void onNext(Long aLong) { Log.d(TAG, aLong ""); } });

timer返回一个Observable,它在延迟一段给定的时间后发射一个简单的数字0。

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

彩民之家论坛9066777 16Timer操作符

03-17 23:46:43.137 12009-12009/com.io.github.hjianfei.demo D/onResponse: created 操作符103-17 23:46:43.137 12009-12009/com.io.github.hjianfei.demo D/onResponse: created 操作符203-17 23:46:43.137 12009-12009/com.io.github.hjianfei.demo D/onResponse: created 操作符303-17 23:46:43.137 12009-12009/com.io.github.hjianfei.demo D/onResponse: created 操作符403-17 23:46:43.137 12009-12009/com.io.github.hjianfei.demo D/onResponse: onCompleted

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

彩民之家论坛9066777 17Interval

代码:

代码:

彩民之家论坛9066777 18Repeat操作符

03-18 00:29:42.656 3065-3533/com.io.github.hjianfei.demo D/onResponse: 003-18 00:29:42.656 3065-3533/com.io.github.hjianfei.demo D/onResponse: onCompleted

Repeat重复地发射数据。某些实现允许你重复的发射某个数据序列,还有一些允许你限制重复的次数。

 Observable.range .subscribe(new Subscriber<Integer>() { @Override public void onCompleted() { Log.d(TAG, "onCompleted"); } @Override public void onError(Throwable e) { Log.d(TAG, "onError:"   e.toString; } @Override public void onNext(Integer integer) { Log.d(TAG, integer   ""); } });
 Observable.timer(2, java.util.concurrent.TimeUnit.SECONDS) .subscribe(new Subscriber<Long>() { @Override public void onCompleted() { Log.d(TAG, "onCompleted"); } @Override public void onError(Throwable e) { Log.d(TAG, "onError:"   e.toString; } @Override public void onNext(Long aLong) { Log.d(TAG, aLong   ""); } });

结果:

TAG标签: 日记本 操作 RxJava
版权声明:本文由彩民之家高手论坛发布于编程技术,转载请注明出处:WranglerxJava 基础操作符的行使入门(创造操作)彩