উদাহরণ সহ বিভিন্ন Operators এর ব্যবহার

RxJava-র Operators হল core tool যা asynchronous এবং event-driven data streams পরিচালনা এবং রূপান্তর করতে সাহায্য করে। এগুলো Observable-এ বিভিন্ন ধরনের পরিবর্তন এবং প্রসেসিং করার জন্য ব্যবহার করা হয়।

1. Creation Operators

Creation Operators নতুন Observables তৈরি করতে সাহায্য করে।

উদাহরণ: just, fromArray, create

import io.reactivex.Observable;

public class CreationOperatorsExample {
    public static void main(String[] args) {
        // Just Operator
        Observable<String> justObservable = Observable.just("Hello", "RxJava");
        justObservable.subscribe(item -> System.out.println("Received: " + item));

        // FromArray Operator
        Observable<Integer> fromArrayObservable = Observable.fromArray(1, 2, 3, 4, 5);
        fromArrayObservable.subscribe(item -> System.out.println("Received: " + item));
    }
}

আউটপুট:

Received: Hello
Received: RxJava
Received: 1
Received: 2
Received: 3
Received: 4
Received: 5

2. Transformational Operators

ডাটা স্ট্রিমকে পরিবর্তন করার জন্য ব্যবহার হয়।

উদাহরণ: map, flatMap

import io.reactivex.Observable;

public class TransformOperatorsExample {
    public static void main(String[] args) {
        // Map Operator
        Observable<Integer> mapObservable = Observable.just(1, 2, 3, 4, 5)
            .map(item -> item * 2); // প্রতিটি element কে গুণ করা হয়
        mapObservable.subscribe(item -> System.out.println("Mapped: " + item));

        // FlatMap Operator
        Observable<String> flatMapObservable = Observable.just("A", "B", "C")
            .flatMap(item -> Observable.just(item + "1", item + "2"));
        flatMapObservable.subscribe(item -> System.out.println("FlatMapped: " + item));
    }
}

আউটপুট:

Mapped: 2
Mapped: 4
Mapped: 6
Mapped: 8
Mapped: 10
FlatMapped: A1
FlatMapped: A2
FlatMapped: B1
FlatMapped: B2
FlatMapped: C1
FlatMapped: C2

3. Filtering Operators

ডাটা ফিল্টার করার জন্য ব্যবহার হয়।

উদাহরণ: filter, take, distinct

import io.reactivex.Observable;

public class FilterOperatorsExample {
    public static void main(String[] args) {
        // Filter Operator
        Observable<Integer> filterObservable = Observable.just(1, 2, 3, 4, 5, 6)
            .filter(item -> item % 2 == 0); // শুধুমাত্র even number রাখে
        filterObservable.subscribe(item -> System.out.println("Filtered: " + item));

        // Distinct Operator
        Observable<Integer> distinctObservable = Observable.just(1, 2, 2, 3, 4, 4, 5)
            .distinct(); // ডুপ্লিকেট সরিয়ে দেয়
        distinctObservable.subscribe(item -> System.out.println("Distinct: " + item));

        // Take Operator
        Observable<Integer> takeObservable = Observable.just(1, 2, 3, 4, 5)
            .take(3); // প্রথম ৩টি element নেয়
        takeObservable.subscribe(item -> System.out.println("Taken: " + item));
    }
}

আউটপুট:

Filtered: 2
Filtered: 4
Filtered: 6
Distinct: 1
Distinct: 2
Distinct: 3
Distinct: 4
Distinct: 5
Taken: 1
Taken: 2
Taken: 3

4. Combining Operators

বিভিন্ন Observable মিশ্রণ বা কম্বিনেশনের জন্য ব্যবহার হয়।

উদাহরণ: merge, zip, concat

import io.reactivex.Observable;

public class CombiningOperatorsExample {
    public static void main(String[] args) {
        // Merge Operator
        Observable<String> mergeObservable = Observable.merge(
            Observable.just("Hello"),
            Observable.just("World")
        );
        mergeObservable.subscribe(item -> System.out.println("Merged: " + item));

        // Zip Operator
        Observable<String> zipObservable = Observable.zip(
            Observable.just("A", "B", "C"),
            Observable.just("1", "2", "3"),
            (s1, s2) -> s1 + s2 // Combine করে
        );
        zipObservable.subscribe(item -> System.out.println("Zipped: " + item));

        // Concat Operator
        Observable<String> concatObservable = Observable.concat(
            Observable.just("First"),
            Observable.just("Second")
        );
        concatObservable.subscribe(item -> System.out.println("Concatenated: " + item));
    }
}

আউটপুট:

Merged: Hello
Merged: World
Zipped: A1
Zipped: B2
Zipped: C3
Concatenated: First
Concatenated: Second

5. Error Handling Operators

Error management-এর জন্য ব্যবহার হয়।

উদাহরণ: onErrorReturn, onErrorResumeNext

import io.reactivex.Observable;

public class ErrorHandlingExample {
    public static void main(String[] args) {
        // OnErrorReturn Operator
        Observable<Integer> onErrorReturnObservable = Observable.just(1, 2, 0, 4)
            .map(item -> 10 / item) // Division by zero exception
            .onErrorReturn(error -> -1); // Error হলে -1 রিটার্ন করবে
        onErrorReturnObservable.subscribe(
            item -> System.out.println("Received: " + item),
            error -> System.err.println("Error: " + error)
        );

        // OnErrorResumeNext Operator
        Observable<Integer> onErrorResumeNextObservable = Observable.just(1, 0, 3)
            .map(item -> 10 / item)
            .onErrorResumeNext(Observable.just(100, 200)); // Error হলে নতুন Observable
        onErrorResumeNextObservable.subscribe(item -> System.out.println("Received: " + item));
    }
}

আউটপুট:

Received: 10
Received: 5
Received: -1
Received: 10
Received: 100
Received: 200

6. Utility Operators

নির্ধারিত কাজ সম্পাদনের জন্য সহায়ক।

উদাহরণ: delay, doOnNext

import io.reactivex.Observable;
import java.util.concurrent.TimeUnit;

public class UtilityOperatorsExample {
    public static void main(String[] args) throws InterruptedException {
        // Delay Operator
        Observable.just("Delayed Hello")
            .delay(2, TimeUnit.SECONDS)
            .subscribe(item -> System.out.println(item));
        
        // DoOnNext Operator
        Observable<Integer> doOnNextObservable = Observable.just(1, 2, 3)
            .doOnNext(item -> System.out.println("Processing: " + item));
        doOnNextObservable.subscribe(item -> System.out.println("Received: " + item));

        Thread.sleep(3000); // Main thread sleep for delay output
    }
}

আউটপুট:

Processing: 1
Received: 1
Processing: 2
Received: 2
Processing: 3
Received: 3
Delayed Hello

উপসংহার

RxJava-এর Operators asynchronous এবং event-driven programming-এর জন্য একটি শক্তিশালী টুলসেট সরবরাহ করে। সঠিক Operators নির্বাচন করলে কাজ সহজ ও কার্যকর হয়। বাস্তব প্রয়োগে অপারেটরগুলির দক্ষ ব্যবহার critical।