Posts RxJava - 데이터 필터링 연산자
Post
Cancel

RxJava - 데이터 필터링 연산자

Posted Dec 12, 2020 2020-12-12T12:10:00+00:00 by Yun-Jae Na
Updated Dec 12, 2020 2020-12-12T13:29:28+00:00

데이터 필터링 연산자

filter

  • 전달 받은 데이터가 조건에 맞는지 확인한 후, 결과가 true인 데이터만 통지한다.
  • filter 라는 단어의 사전적 의미가 무언가를 걸러낸다는 의미이다.
  • 파라미터로 받는 Predicate 함수형 인터페이스에서 조건을 확인한다.

filter

1
2
3
4
5
6
7
8
9
10
11
12

public class ObservableFilterExample01 {
    public static void main(String[] args) {
        Observable.fromIterable(SampleData.carList)
                .filter(car -> car.getCarMaker() == CarMaker.CHEVROLET)
                .subscribe(car -> Logger.log(LogType.ON_NEXT, car.getCarMaker() + " : " + car.getCarName()));
    }
}
/*
onNext() | main | 19:36:26.584 | CHEVROLET : 말리부
onNext() | main | 19:36:26.588 | CHEVROLET : 트래버스
onNext() | main | 19:36:26.589 | CHEVROLET : 트랙스
*/

1
2
3
4
5
6
7
8
9
10
11

public class ObservableFilterExample02 {
    public static void main(String[] args) {
        Observable.fromIterable(SampleData.carList)
                .filter(car -> car.getCarMaker() == CarMaker.CHEVROLET)
                .filter(car -> car.getCarPrice() > 30000000)
                .subscribe(car -> Logger.log(LogType.ON_NEXT, car.getCarName()));
    }
}
/*
onNext() | main | 19:40:59.182 | 트래버스
*/

distinct

  • 이미 통지된 동일한 데이터가 있다면 이후의 동일한 데이터는 통지 하지 않는다.
  • distinct의 사전적 의미는 ‘명확하게 구별되는’ 이라는 뜻을 포함하고 있다.

distinct

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class ObservableDistinctExample01 {
    public static void main(String[] args) {
        Observable.fromArray(SampleData.carMakersDuplicated)
                .distinct()
                .subscribe(carMaker -> Logger.log(LogType.ON_NEXT, carMaker));
    }
}
/*
onNext() | main | 19:47:14.840 | CHEVROLET
onNext() | main | 19:47:14.843 | HYUNDAE
onNext() | main | 19:47:14.843 | SAMSUNG
onNext() | main | 19:47:14.843 | SSANGYOUNG
onNext() | main | 19:47:14.843 | KIA
*/

1
2
3
4
5
6
7
8
9
10
11

public class ObservableDistinctExample02 {
    public static void main(String[] args) {
        Observable.fromArray(SampleData.carMakersDuplicated)
                .distinct()
                .filter(carMaker -> carMaker == CarMaker.SSANGYOUNG)
                .subscribe(carMaker -> Logger.log(LogType.ON_NEXT, carMaker));
    }
}
/*
onNext() | main | 19:48:55.776 | SSANGYOUNG
*/

1
2
3
4
5
6
7
8
9
10
11
12
13

public class ObservableDistinctExample03 {
    public static void main(String[] args) {
        Observable.fromIterable(SampleData.carList)
                .distinct(car -> car.getCarMaker())
                .subscribe(car -> Logger.log(LogType.ON_NEXT, car.getCarName()));
    }
}
/*
onNext() | main | 19:51:55.237 | 말리부
onNext() | main | 19:51:55.241 | 쏘렌토
onNext() | main | 19:51:55.241 | 티볼리
onNext() | main | 19:51:55.242 | SM6
*/

take

  • 파라미터로 지정한 개수나 기간이 될 때까지 데이터를 통지한다.
  • 지정한 범위가 통지 데이터보다 클 경우 데이터를 모두 통지하고 완료한다.

take

1
2
3
4
5
6
7
8
9
10
11

public class ObservableTakeExample01 {
    public static void main(String[] args) {
        Observable.just("a","b","c","d")
                .take(2)
                .subscribe(data -> Logger.log(LogType.ON_NEXT, data));
    }
}
/*
onNext() | main | 19:57:18.154 | a
onNext() | main | 19:57:18.159 | b
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class ObservableTakeExample02 {
    public static void main(String[] args) {
        Observable.interval(1000L, TimeUnit.MILLISECONDS)
                .take(3500L, TimeUnit.MILLISECONDS)
                .subscribe(data -> Logger.log(LogType.ON_NEXT, data));

        TimeUtil.sleep(3500L);
    }
}
/*
onNext() | RxComputationThreadPool-2 | 19:59:01.558 | 0
onNext() | RxComputationThreadPool-2 | 19:59:02.524 | 1
onNext() | RxComputationThreadPool-2 | 19:59:03.523 | 2
*/

takeUntil 첫번째 유형

  • 파라미터로 지정한 조건이 true가 될 떄까지 데이터를 계속 통지한다.

takeUntil

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * 파라미터로 지정한 조건이 될 때까지 데이터를 계속 발행
 */
public class ObservableTakeUntilExample01 {
    public static void main(String[] args) {
        Observable.fromIterable(SampleData.carList)
                .takeUntil((Car car) -> car.getCarName().equals("트랙스"))
                .subscribe(car -> System.out.println(car.getCarName()));

        TimeUtil.sleep(300L);
    }
}
/*
말리부
쏘렌토
트래버스
팰리세이드
트랙스
*/

takeUntil 두번째 유형

  • 파라미터로 지정한 Observable이 최초 데이터를 통지할 때까지 데이터를 계속 통지한다.

takeUntilSecond

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * 파라미터로 받은 Flowable/Observable이 최초로 데이터를 발행할 때까지 계속 데이터를 발행
 * timer와 함께 사용하여 특정 시점이 되기전까지 데이터를 발행하는데 활용하기 용이
 */
public class ObservableTakeUntilExample02 {
    public static void main(String[] args) {
        Observable.interval(1000L, TimeUnit.MILLISECONDS)
                .takeUntil(Observable.timer(5500L, TimeUnit.MILLISECONDS))
                .subscribe(data -> Logger.log(LogType.ON_NEXT, data));

        TimeUtil.sleep(5500L);
    }
}
/*
onNext() | RxComputationThreadPool-2 | 20:38:44.070 | 0
onNext() | RxComputationThreadPool-2 | 20:38:45.037 | 1
onNext() | RxComputationThreadPool-2 | 20:38:46.036 | 2
onNext() | RxComputationThreadPool-2 | 20:38:47.037 | 3
onNext() | RxComputationThreadPool-2 | 20:38:48.037 | 4
*/

skip 첫 번째 유형

  • 파라미터로 지정한 숫자만큼 데이터를 건너뛴 후 나머지 데이터를 통지한다.

skip

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class ObservableSkipExample01 {
  public static void main(String[] args) {
    Observable.range(1, 15)
        .skip(3)
        .subscribe(data -> Logger.log(LogType.ON_NEXT, data));
  }
}
/*
onNext() | main | 20:48:30.123 | 4
onNext() | main | 20:48:30.126 | 5
onNext() | main | 20:48:30.126 | 6
onNext() | main | 20:48:30.127 | 7
onNext() | main | 20:48:30.127 | 8
onNext() | main | 20:48:30.127 | 9
onNext() | main | 20:48:30.127 | 10
onNext() | main | 20:48:30.127 | 11
onNext() | main | 20:48:30.127 | 12
onNext() | main | 20:48:30.127 | 13
onNext() | main | 20:48:30.127 | 14
onNext() | main | 20:48:30.127 | 15
*/

skip 두번째 유형

  • 파라미터로 지정한 시간 동안에는 데이터를 통지를 건너뛴 후 지정한 시간 이 후, 나머지 데이터를 통지한다.

skip second

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class ObservableSkipExample02 {
    public static void main(String[] args) {
        Observable.interval(300L, TimeUnit.MILLISECONDS)
                .skip(1000L, TimeUnit.MILLISECONDS)
                .subscribe(data -> Logger.log(LogType.ON_NEXT , data));

        TimeUtil.sleep(3000L);
    }
}
/*
onNext() | RxComputationThreadPool-2 | 20:56:51.770 | 3
onNext() | RxComputationThreadPool-2 | 20:56:52.034 | 4
onNext() | RxComputationThreadPool-2 | 20:56:52.335 | 5
onNext() | RxComputationThreadPool-2 | 20:56:52.636 | 6
onNext() | RxComputationThreadPool-2 | 20:56:52.935 | 7
onNext() | RxComputationThreadPool-2 | 20:56:53.235 | 8
onNext() | RxComputationThreadPool-2 | 20:56:53.535 | 9
*/

기타 예시

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
 * filter를 이용하여 SampleData.carList 중에서 CarMaker가 SSANGYOUNG인 차들의 carName을 출력하세요.
 */
public class QuizAnswerForChapter050201 {
    public static void main(String[] args) {
        Observable.fromIterable(SampleData.carList)
                .filter(car -> car.getCarMaker() == CarMaker.SSANGYOUNG)
                .subscribe(car -> Logger.log(LogType.ON_NEXT, car.getCarName()));
    }
}
/*
onNext() | main | 21:18:14.609 | 티볼리
onNext() | main | 21:18:14.615 | G4렉스턴
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
 * interval, takeWhile을 이용하여 발행된 숫자가 10이 아닌동안 데이터를 1초에 한번씩 계속 출력하세요.
 */
public class QuizAnswerForChapter050202 {
    public static void main(String[] args) {
        Observable.interval(1000L, TimeUnit.MILLISECONDS)
                .takeWhile(data -> data != 10)
                .subscribe(data -> Logger.log(LogType.ON_NEXT, data));

        TimeUtil.sleep(10000L);
    }
}
/*
onNext() | RxComputationThreadPool-1 | 21:18:43.238 | 0
onNext() | RxComputationThreadPool-1 | 21:18:44.151 | 1
onNext() | RxComputationThreadPool-1 | 21:18:45.151 | 2
onNext() | RxComputationThreadPool-1 | 21:18:46.151 | 3
onNext() | RxComputationThreadPool-1 | 21:18:47.152 | 4
onNext() | RxComputationThreadPool-1 | 21:18:48.151 | 5
onNext() | RxComputationThreadPool-1 | 21:18:49.151 | 6
onNext() | RxComputationThreadPool-1 | 21:18:50.152 | 7
onNext() | RxComputationThreadPool-1 | 21:18:51.152 | 8
onNext() | RxComputationThreadPool-1 | 21:18:52.151 | 9
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * interval, skipUntil, timer를 이용하여 1초에 한번씩 발행된 데이터 중에서 3초 후에 발행된 데이터만 10까지 출력하세요.
 */
public class QuizAnswerForChapter050203 {
    public static void main(String[] args) {
       Observable.interval(1000L, TimeUnit.MILLISECONDS)
               .skipUntil(Observable.timer(3000L, TimeUnit.MILLISECONDS))
               .subscribe(data -> Logger.log(LogType.ON_NEXT, data));

       TimeUtil.sleep(11500L);
    }
}
/*
onNext() | RxComputationThreadPool-2 | 21:19:55.980 | 3
onNext() | RxComputationThreadPool-2 | 21:19:56.918 | 4
onNext() | RxComputationThreadPool-2 | 21:19:57.917 | 5
onNext() | RxComputationThreadPool-2 | 21:19:58.918 | 6
onNext() | RxComputationThreadPool-2 | 21:19:59.918 | 7
onNext() | RxComputationThreadPool-2 | 21:20:00.917 | 8
onNext() | RxComputationThreadPool-2 | 21:20:01.917 | 9
onNext() | RxComputationThreadPool-2 | 21:20:02.915 | 10
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
 * range, skipLast를 이용하여 1부터 15까지의 숫자중에서 마지막에 발행된 숫자 3개를 제외한 나머지 숫자를 출력하세요.
 */
public class QuizAnswerForChapter050204 {
    public static void main(String[] args) {
        Observable.range(1, 15)
                .skipLast(3)
                .subscribe(data -> Logger.log(LogType.ON_NEXT, data));
    }
}
/*
onNext() | main | 21:20:32.993 | 1
onNext() | main | 21:20:32.996 | 2
onNext() | main | 21:20:32.996 | 3
onNext() | main | 21:20:32.996 | 4
onNext() | main | 21:20:32.996 | 5
onNext() | main | 21:20:32.996 | 6
onNext() | main | 21:20:32.996 | 7
onNext() | main | 21:20:32.996 | 8
onNext() | main | 21:20:32.996 | 9
onNext() | main | 21:20:32.996 | 10
onNext() | main | 21:20:32.996 | 11
onNext() | main | 21:20:32.996 | 12
*/

이 글은 inflearn에 있는 Kevin의 알기 쉬운 RxJava 1부를 공부하고 작성한 글입니다.
강의영상 링크

Android, RxJava
Android RxJava
This post is licensed under CC BY 4.0 by the author.

Recent Update

Contents

RxJava - 연산자 개요 및 생성 연산자

RxJava - 데이터 변환 연산자 (1)

Comments powered by Disqus.