rx-java
演算子

備考

オペレーター、紹介

ObservableからSubscriberへのオブジェクトの流れを操作するために、演算子を使用することができます。

Observable<Integer> integerObservable = Observable.just(1, 2, 3); // creating a simple Integer observable
Subscriber<String> mSubscriber = new Subscriber<String>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted called!");
    }

    @Override
    public void onError(Throwable throwable) {
        System.out.println("onError called");
    }

    @Override
    public void onNext(String string) {
        System.out.println("onNext called with: " + string);
    }
}; // a simple String subscriber

integerObservable
    .map(new Func1<Integer, String>() {
        @Override
        public String call(Integer integer) {
            switch (integer) {
                case 1:
                    return "one";
                case 2:
                    return "two";
                case 3:
                    return "three";
                default:
                    return "zero";
            }
        }
}).subscribe(mSubscriber);

出力は次のようになります。

onNext called with: one
onNext called with: two
onNext called with: three
onCompleted called!

map演算子は、 Integer observableをString observableに変更し、オブジェクトのフローを操作しました。

オペレーターチェーン

より強力な変換と操作のために、複数の演算子をchainedさせることができます。

integerObservable // emits 1, 2, 3
            .map(i -> i + 10) // adds 10 to each item; emits 11, 12, 13
            .filter(i -> i > 11) // emits items that satisfy condition; 12, 13
            .last() // emits last item in observable; 13
            // unlimited operators can be added ...
            .subscribe(System.out::println); // prints 13

ObservableとSubscriber間には、任意の数の演算子を追加できます。

flatMap演算子

flatMap演算子は、あるイベントを別のObservableに変換するのに役立ちます（または、イベントを1つ、または複数のイベントに変換します）。

これはObservableを返す別のメソッドを呼び出すときには完璧な演算子です

 public Observable<String> perform(int i) {
      // ...
 }

 Observable.just(1, 2, 3)
           .flatMap(i -> perform(i))
           .subscribe(result -> System.out.println("result ->" + result);

flatMapシリアライズされますperformことにより、emitedサブスクリプションが、イベントのperform命じたことがないかもしれません。したがって、最初のperformコールからのイベントの前に最後に実行されたイベントによってイベントが受信される場合があります（代わりにconcatMapを使用する必要があります）。

あなたのサブスクライバで別のObservableを作成する場合は、代わりにflatMap を使用する必要があります。主なアイデアは、Observable

例えば ​​：

 Observable.just(1, 2, 3)
           .subscribe(i -> perform(i));

次のように簡単に置き換えることができます：

 Observable.just(1, 2, 3)
           .flatMap(i -> perform(i))
           .subscribe();

Reactivex.ioのドキュメント： http : //reactivex.io/documentation/operators/flatmap.html

フィルタ演算子

filter演算子を使用して、述語メソッドの結果に基づいて値ストリームから項目をフィルタリングできます。

つまり、オブザーバからサブスクライバに渡されるアイテムは、 filterを渡す関数に基づいて破棄されます。関数が特定の値に対してfalseを返す場合、その値は除外されます。

例：

List<Integer> integers = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Observable.from(integers)
    .filter(number -> {
        return (number  % 2 == 0); 
        // odd numbers will return false, that will cause them to be filtered 
    })
    .map(i -> {
        return Math.pow(i, 2); // take each number and multiply by power of 2
    }) 
    .subscribe(onNext -> {
         System.out.println(onNext); // print out the remaining numbers
    });

このコードは印刷されます

0.0
4.0
16.0
36.0
64.0

地図演算子

map演算子を使用すると、 map渡された関数の各値の結果に基づいて、ストリームの値を異なる値にmap 。結果ストリームは新しいコピーであり、指定された値のストリームを変更しません。結果ストリームの長さは入力ストリームの長さと同じですが、異なるタイプである可能性があります。

.map()渡された関数は、値を返す必要があります。

例：

List<Integer> numbers = Arrays.asList(1, 2, 3);
Observable.from(numbers)
    .map(number -> {
        return number.toString(); // convert each integer into a string and return it
    }) 
    .subscribe(onNext -> {
         System.out.println(onNext); // print out the strings
    });

このコードは印刷されます

"1"
"2"
"3"

この例では、ObservableがList<Integer>受け入れると、 List<Integer>はパイプラインのList<String>に変換され、 .subscribeはString .subscribeます

doOnNext演算子

ソースObservableがアイテムをdoOnNextたびに呼び出されるdoOnNext演算子。それは、デバッグのために使用され、放出されたアイテムにいくつかのアクションを適用し、ロギングするなど...

Observable.range(1, 3)
    .doOnNext(value -> System.out.println("before transform: " + value))
    .map(value -> value * 2)
    .doOnNext(value -> System.out.println("after transform: " + value))
    .subscribe();

以下の例ではdoOnNextソースためと呼ばれることはありませんObservableあるため、何も発しないObservable.empty()の呼び出しonCompleted加入した後。

Observable.empty()
    .doOnNext(item -> System.out.println("item: " + item))
    .subscribe();

繰り返し演算子

repeatオペレータは、ソースからの全シーケンスを繰り返すことができObservable 。

Observable.just(1, 2, 3)
    .repeat()
    .subscribe(
        next -> System.out.println("next: " + next),
        error -> System.out.println("error: " + error),
        () -> System.out.println("complete")
    );

上記の例の出力

next: 1
next: 2
next: 3
next: 1
next: 2
next: 3

このシーケンスは無限回繰り返され、決して完了しません。

シーケンスを有限回repeat 、整数を引数として渡してオペレータをrepeatます。

Observable.just(1, 2, 3)
    // Repeat three times and complete
    .repeat(3)
    .subscribe(
        next -> System.out.println("next: " + next),
        error -> System.out.println("error: " + error),
        () -> System.out.println("complete")
    );

この例では、

next: 1
next: 2
next: 3
next: 1
next: 2
next: 3
next: 1
next: 2
next: 3
complete

ソースのObservableシーケンスが完了したときに、 repeat演算子がソースObservableに再登録することを理解することは非常に重要です。上記の例をObservable.createを使って書き直してみましょう。

Observable.<Integer>create(subscriber -> {

    //Same as Observable.just(1, 2, 3) but with output message
    System.out.println("Subscribed");
    subscriber.onNext(1);
    subscriber.onNext(2);
    subscriber.onNext(3);
    subscriber.onCompleted();
})
        .repeat(3)
        .subscribe(
                next -> System.out.println("next: " + next),
                error -> System.out.println("error: " + error),
                () -> System.out.println("complete")
        );

この例では、

Subscribed
next: 1
next: 2
next: 3
Subscribed
next: 1
next: 2
next: 3
Subscribed
next: 1
next: 2
next: 3
complete

演算子連鎖を使用する場合、 repeat演算子が演算子の前ではなくシーケンス全体をrepeatことが重要です。

Observable.<Integer>create(subscriber -> {
    System.out.println("Subscribed");
    subscriber.onNext(1);
    subscriber.onNext(2);
    subscriber.onNext(3);
    subscriber.onCompleted();
})
        .map(value -> value * 2) //First chain operator
        .map(value -> "modified " + value) //Second chain operator
        .repeat(3)
        .subscribe(
                next -> System.out.println("next: " + next),
                error -> System.out.println("error: " + error),
                () -> System.out.println("complete")
        );

この例では、

Subscribed
next: modified 2
next: modified 4
next: modified 6
Subscribed
next: modified 2
next: modified 4
next: modified 6
Subscribed
next: modified 2
next: modified 4
next: modified 6
complete

この例では、ことを示してrepeatオペレータは、シーケンス全体にresubscribing繰り返してObservableではなく、最後の繰り返しmap演算子を、シーケンス内のどの場所でもかまいませんrepeat演算子を使用します。

このシーケンス

Observable.<Integer>create(subscriber -> {
        //...
    })
    .map(value -> value * 2) //First chain operator
    .map(value -> "modified " + value) //Second chain operator
    .repeat(3)
    .subscribe(
        /*....*/
    );

このシーケンスに等しい

Observable.<Integer>create(subscriber -> {
        //...
    })
    .repeat(3)
    .map(value -> value * 2) //First chain operator
    .map(value -> "modified " + value) //Second chain operator
    .subscribe(
        /*....*/
    );