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 변환하거나 이벤트를 0 개, 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 . 결과 스트림은 새로운 사본이며 제공된 값 스트림을 수정하지 않으며 결과 스트림의 입력 스트림 길이는 같지만 유형은 다를 수 있습니다.

.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 의

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 연산자를 사용하십시오.

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

repeat Observable 연산자가 소스 Observable 시퀀스를 완료 할 때 Observable repeat 구독한다는 것을 이해하는 것이 매우 중요합니다. Observable.create 사용하여 위의 예제를 다시 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 연산자가 마지막 map 연산자를 반복하지 않고 전체 시퀀스를 repeat Observable 되풀이하며 시퀀스 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(
        /*....*/
    );