RxJava操作符

标签：RxJava

---

创建操作

1.create

从头开始创建一个Observable，最简单暴力的方式。

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        };
        Observable observable = Observable.create(subscriber1 -> {
            subscriber1.onNext("'original'" + System.currentTimeMillis());
            subscriber1.onCompleted();
        }).map(o -> o + " 'change' ");
//        observable.map(o -> "no used"); // unknown reason
        observable.map(o -> o + "first change\n").subscribe(subscriber);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        observable.subscribe(subscriber);

结果：

'original'1456220880081 'change' first change
'original'1456220881087 'change' 

疑问1：
两次打印结果时间不同，是否说明创建了两个Observable对象？

2.defer

Observable.defer(Func0

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        };
Observable observable = Observable.defer(() -> Observable.create(s -> {
            s.onNext("'original'" + System.currentTimeMillis());
            s.onCompleted();
        }));

observable.map(s -> s + " no used map ").subscribe(subscriber);
//        observable.map(s -> s + " map ");     // unknown reason
//        observable.subscribe(subscriber1);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        observable.map(s -> s + " serial map \n").subscribe(subscriber);

结果：

'original'1456221620395 no used map 
'original'1456221621401 serial map 

疑问2：
打印结果中的时间不同，是否说明了创建了两个Observable对象？如果不是，那如果证明defer会为每一个订阅者创建不同的Observable？

3.Empty/Never/Throw

Empty创建一个不发射任何数据但是正常终止的Observable。
Never创建一个不发射数据也不终止的Observable。
Throw创建一个不发射数据以一个错误终止的Observable。
这三个操作符生成的Observable使用非常有限。例如empty可用于“做一些处理”的操作，如:

private void runInMainThread(@NonNull XRFunc xrFunc) {
        Observable.empty()
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(o -> {
                }, throwable -> Logger.e(TAG, throwable), xrFunc::call);
    }

4.From

常用方法有from(array)/from(Iterable)。可见from可以接收一个数组、集合、Future。from将接收的每一个对象都转成Observable对象，并依次排出。可以用于迭代处理数据。

List<String> list = new ArrayList<>();
        list.add("chinese");
        list.add("english");
        Observable.from(list)
                .subscribe(s -> System.out.println(s));

结果：

chinese
english

5.Interval

创建一个固定时间间隔发射整数序列的Observable。
interval(long,long,TimeUnit))

6.Just

创建一个发射指定数据的Observable。Just接收一个数据或者一个集合。Just将单个数据转换成发射那个数据的Observable，将集合也当成单个数据，原样发射。

Observable.just(1, 2, 3)
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

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

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

结果：

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

疑问3：
From和Just具体应用场景有什么不同？

7.Range

创建一个发射特定整数序列的Observable。
range(int,int))

8.Repeat

创建一个发射特定数据重复多次的Observable。

9.Start

返回一个Observable，它发射一个类似于函数声明的值

10.Timer

创建一个Observable，它在一个给定的延迟后发射一个特殊的值。