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 एक करने के लिए नमूदार String नमूदार, जिससे वस्तुओं के प्रवाह से छेड़छाड़।

संचालन करने वाला

अधिक शक्तिशाली परिवर्तनों और जोड़तोड़ के लिए कई ऑपरेटरों को एक साथ 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 ऑपरेटर आपको एक घटना को दूसरे Observable (या किसी घटना को शून्य, एक या अधिक घटनाओं में बदलने) में बदलने में मदद करता है।

जब आप किसी अन्य विधि को कॉल करना चाहते हैं जो एक 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 को क्रमबद्ध करेगा, लेकिन perform द्वारा उत्सर्जित घटनाओं का आदेश नहीं दिया जा सकता है। तो अगर आप पिछले द्वारा उत्सर्जित घटनाओं प्राप्त हो सकता है प्रदर्शन पहले से घटनाओं से पहले कॉल perform कॉल (आप का उपयोग करना चाहिए concatMap बजाय)।

यदि आपका एक और बनाने Observable आपके ग्राहक में, आप का उपयोग करना चाहिए flatMap बजाय। मुख्य विचार है: ऑब्जर्वेबल को कभी न छोड़ें

उदाहरण के लिए :

 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() को दिया गया, मान वापस करना होगा।

उदाहरण:

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"

इस उदाहरण में प्रत्यक्ष स्वीकार किए जाते हैं एक List<Integer> सूची एक करने के लिए परिवर्तित हो जाएगा List<String> पाइप लाइन में और .subscribe उत्सर्जित करेगा String की

doNNext ऑपरेटर

doOnNext ऑपरेटर हर बार जब स्रोत कहा जाता है Observable का उत्सर्जन करता है एक आइटम। इसका उपयोग डिबगिंग उद्देश्यों के लिए किया जा सकता है, उत्सर्जित वस्तु, लॉगिंग आदि के लिए कुछ कार्रवाई लागू कर सकता है ...

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 ऑपरेटर पूर्ववर्ती ऑपरेटर के बजाय पूरे अनुक्रम को दोहराता है।

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 ऑपरेटर के लिए पुन: सदस्य बनकर पूरे अनुक्रम दोहराता 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(
        /*....*/
    );