[리액티브 프로그래밍] 리액티브 연산자 입문

안녕하세요. 블랙진입니다.

한빛미디어 RxJava프로그래밍을 보며 리액티브를 공부한 내용을 정리하기 위한 두번째 포스팅입니다.

Chapter 3

3.1 Map() 함수

/**
 *  Map 함수는 입력값을 어떤 함수에 넣어서 원하는 값으로 변환하는 함수
 */
public void getStarMap() {
    String[] balls = {"1","2","3","4"};

    Observable<String> source = Observable.fromArray(balls)
            .map(ball -> ball + "☆");
    source.subscribe(System.out::println);
    
}

public void getStarMap() {
    String[] balls = {"1","2","3","4"};

    Function<String, String> getStar = ball -> ball + "☆";
    Observable<String> source = Observable.fromArray(balls)
            .map(getStar);
    source.subscribe(System.out::println);
}

(결과)

main: 1☆

main: 2☆

main: 3☆

main: 4☆

Map() 함수의 원형

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}

@CheckReturnVale 는 반환값을 확인한다는 의미입니다.

@SchedulerSuppoer(value="none") 는 스케줄러를 지원하지 않는다는 의미입니다. 즉 현재 스레드에서 실행합니다.

Function<? super T, ? extends R> mapper

Function<T, R> 은 T(입력) 값을 받아서 R(결과) 를 반환합니다.

3.2 flatMap() 함수

/**
 * FlatMap 함수는 결과가 Observable 로 나옵니다.
 * 일대다 혹은 일대일 Observable 함수입니다.
 */
public void getDoubleStartMap() {

    Function<String, Observable<String>> getDoubleStart =
            ball -> Observable.just(ball + "☆", ball + "☆");

    String[] balls = {"1","2","3"};

    Observable<String> source = Observable.fromArray(balls)
            .flatMap(getDoubleStart);
    source.subscribe(System.out::println);
}

(결과)

main: 1☆

main: 1☆

main: 2☆

main: 2☆

main: 3☆

main: 3☆

3.3 filter() 함수

/**
 *  Observable 에서 원하는 데이터만 걸러내는 역활
 */
public void getCircleFilter() {

    String[] objs = {"1 CIRCLE","2 DIAMOND","3 TRIANGLE","4 CIRCLE","5 DIAMOND","6 TRIANGLE"};

    Observable<String> source = Observable.fromArray(objs)
            .filter(obj -> obj.endsWith("CIRCLE"));

    source.subscribe(System.out::println);
}

filter() 함수와 비슷한 함수들

Integer[] numbers = {100, 200, 300, 400, 500};
Single<Integer> single;
Observable<Integer> source;

// 1. first - Observable의 첫 번째 값을 필터함. 만약 값없이 완료되면 대신 기본값을 리턴함
single = Observable.fromArray(numbers).first(-1);
single.subscribe(data -> System.out.println("first() value = " + data));

// 2. last - Observable의 마지막 값을 필터함. 만약 값없이 완료되면 대신 기본값을 리턴함
single = Observable.fromArray(numbers).last(999);
single.subscribe(data -> System.out.println("last() value = " + data));

// 3. take - 최초 N개 값만 가져옴
source = Observable.fromArray(numbers).take(3);
source.subscribe(data -> System.out.println("take(3) value = " + data));

// 4. takeLast - 마지막 N개 값만 필터함
source = Observable.fromArray(numbers).takeLast(3);
source.subscribe(data -> System.out.println("takeLast(3) value = " + data));

// 5. skip - 최초 N개 값을 건너뜀
source = Observable.fromArray(numbers).skip(2);
source.subscribe(data -> System.out.println("skip(2) value = " + data));

// 5. skipLast - 마지막 N개 값을 건너띔
source = Observable.fromArray(numbers).skipLast(2);
source.subscribe(data -> System.out.println("skipLast(2) value = " + data));

(결과)

first() value = 100

last() value = 500

take(3) value = 100

take(3) value = 200

take(3) value = 300

takeLast(3) value = 300

takeLast(3) value = 400

takeLast(3) value = 500

skip(2) value = 300

skip(2) value = 400

skip(2) value = 500

skipLast(2) value = 100

skipLast(2) value = 200

skipLast(2) value = 300

3.4 reduce() 함수

/**
 *  reduce() 함수는 발행한 데이터를 모두 사용하여 어떤 최종 결과 데이터를 합성할 때 활용
 */
public class ReduceExample {

    public void example() {

        String[] balls = {"1", "3", "5"};
        Maybe<String> source = Observable.fromArray(balls)
                .reduce((ball1, ball2) -> ball2 + "(" + ball1 + ")");
        source.subscribe(System.out::println);
    }
}

(결과)

5(3(1))

3.4.1 데이터 쿼리하기

/**
 *  TV : 2500
 *  Camera : 300
 *  TV : 1600
 *  Phone : 800
 *
 *  1. 전체 매출 데이터를 입력함.
 *  2. 매출 데이터 중 TV 매출을 필터링 함
 *  3. TV 매출의 합을 구함
 */

(결과)

// 1. 데이터 입력
item[] data = {new item("TV", 2500), new item("Camera", 300),
        new item("TV", 1600), new item("Phone", 800)};

Maybe<Integer> tvSales = Observable.fromArray(data)
        // 2. 매출 데이터 중 TV 매출을 필터링함
        .filter(sale -> "TV".equals(sale.getName()))
        .map(sale -> sale.getPrice())
        // 3. TV 매출의 합을 구함
        .reduce((sale1, sale2) -> sale1 + sale2);

tvSales.subscribe(tot -> System.out.println("TV Sales : $ : " + tot));

class item {

    private String name;
    private int price;

    item(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }
}