Java8 의 등장으로 드디어 Java를 사용하는 어플리케이션에서, 함수형 프로그래밍을 할 수 있게 되었습니다. Lambda 를 사용할 수 있으면서, Collection 처리를 선언형으로 처리할 수 있다면 매우 매력적일 것이라 생각합니다.


그러나 아쉽게도 안드로이드에서는 안좋은 소식이 있습니다. 강력한 Stream API 를 24 버전 이 후부터 사용할 수 있습니다. 하위호환성이란 문제를 생각해야하는 입장에서 24버전을 minimum 으로 맞춰두고 개발하기란 쉽지 않을 것 같습니다.


Call requires API level 24 (current min is 15): java.util.Collection#stream


하지만 이를 커버할 수 있는 방법 중 하나는 안드로이드에서 반응형 프로그래밍을 할 수 있는 RxAndroid2(RxJava2 포함) 를 사용하는 방법이라 할 수 있을 것 같습니다. 


글 작성 기준 (2017.02.27) RxJava2 가 새로 등장하였으며, 이를 기준으로 Stream 과 호환할 수 있는 메소드 사용법에 대해 포스팅해보려 합니다. (간단한 예제는 생략합니다. ㅡㅡ^)


일단 gradle 로 다음 RxJava 라이브러리들을 다운 받습니다. 


RxAndroid2 : https://github.com/ReactiveX/RxAndroid


Rx-java-extension : https://github.com/jacek-marchwicki/rx-java-extensions



1. RxJava2 에서의 매칭


Collection 클래스 내에서 매칭을 하여 결과를 알 수 있다는 것은 꽤 유용한 방법이었습니다. 


해당 결과를 가진 데이터가 존재하는가? 혹은 모든 데이터가 해당 결과를 만족하는가? 등 우리는 Java8 에서 단순히 선언만으로 데이터를 처리할 수 있었습니다.



RxJava2 에서도 크게 다르지는 않습니다.


다음과 같이 any 와 all 을 사용할 수 있습니다.


1
2
3
4
5
6
7
8
9
10
11
List<Integer[]> testT = Arrays.asList(new Integer[]{25},new Integer[]{38}, new Integer[]{3,5});
            
// 일부 매칭.
Observable.fromIterable(testT).
        map(arrays -> Arrays.asList(arrays)).
        any(list -> !list.contains(8)).blockingGet();
 
// 전체 매칭
Observable.fromIterable(testT).
        map(arrays -> Arrays.asList(arrays)).
        all(list -> !list.contains(8)).blockingGet();
cs



2. flatMap 을 통한 컬렉션 join


컬렉션 내부의 제네릭객체를 join 할 수 있는 flapMap 에 대해서 소개한 적이 있습니다. 



RxJava2 에서도 방법은 크게 다르지 않습니다. 호환성있게 지원이 됩니다. 아래와 같이 말이죠.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
List<MemberVo> memberVoList = Arrays.asList(
        new MemberVo(1"Doohyun Nam",28)
        , new MemberVo(2"Duckhyung Yuu"27));
 
List<PersonalInfoVo> personalInfoVoList = Arrays.asList(
        new PersonalInfoVo(1"My Way Functional Programming")
        , new PersonalInfoVo(2"My Way Spring FrameWork"));
 
Observable.fromIterable(memberVoList).
        flatMap(memberVo -> Observable.fromIterable(personalInfoVoList).
                                filter(personalInfoVo -> personalInfoVo.getMemberSubjectSn().equals(memberVo.getMemberSubjectSn())).map(personalInfoVo -> {
                            MemberPersonalVo memberPersonalVo = new MemberPersonalVo();
                            memberPersonalVo.setGoal(personalInfoVo.getGoal());
                            memberPersonalVo.setName(memberVo.getName());
                            return memberPersonalVo;
                        })).
        forEach(System.out::println); 
 
// Result
// Doohyun Nam : My Way Functional Programming
// Duckhyung Yuu : My Way Spring FrameWork
cs



3. Grouping 과 Partitioning 


컬렉션 데이터를 특정 조건으로 분류하고, 그 결과를 Map 으로 만들어주던 이 기능은 많은 비지니스 로직개선에 도움이 되었습니다. Collector 의 팩토리 메소드 몇개만 사용하면 쉽게 이용할 수 있었습니다.



그러나 RxJava2 에서는 이를 활용하기가 조금 까다롭습니다. Java8 의 Stream 처럼 collect 메소드를 지원하지만, 같이 사용가능한 Collectors 군의 팩토리 메소드들과 같은 유틸성 기능을 제공하지 않습니다.


대신에 toMap, toMultiMap, groupby 등의 메소드를 사용할 수 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
List<SubjectRelation> subjectRelationList = Arrays.asList(
                    new SubjectRelation(11001"Doohyun Nam"1)
                    , new SubjectRelation(11002"Dolkin"2)
                    , new SubjectRelation(11003"hshawng"1)
                    , new SubjectRelation(11004"spKwon"1)
                    , new SubjectRelation(21005"Other Person1"3)
                    , new SubjectRelation(21006"Other Person2"4)
            );
 
// create Map
Map<Integer, Collection<String>> mapTest = Observable.fromIterable(subjectRelationList).
           toMultimap(SubjectRelation::getCompanySubjectSn, SubjectRelation::getMemberName).
           blockingGet();
 
 
// only subscribe
Observable.fromIterable(subjectRelationList)
            .groupBy(SubjectRelation::getCompanySubjectSn).subscribe(group -> {
                  System.out.println(group.getKey());
                group.map(SubjectRelation::getMemberName).forEach(System.out::println);
            });
 
// create multi group
 Map<Integer, Map<Integer, Collection<String>>> doubleKeyMap = new HashMap<>();
            Observable.fromIterable(subjectRelationList).
                    groupBy(SubjectRelation::getCompanySubjectSn).
                    blockingSubscribe(group ->
                        doubleKeyMap.put(group.getKey(),
                                group.toMultimap(
                                        SubjectRelation::getOrganizationSubjectSn
                                        , SubjectRelation::getMemberName).blockingGet())
                    );
 
// partitioning
Map<Boolean, Collection<String>> partitioningMap = Observable.fromIterable(subjectRelationList).
             toMultimap(subjectRelation -> subjectRelation.getCompanySubjectSn().intValue() == 1
                 , SubjectRelation::getMemberName).
             blockingGet();
cs


세 번째 라인의 key 두 개를 이용하여 만든 맵의 경우 딱 맵까지 만들어주는 방법을 찾지는 못했습니다. 뭔가 우회해서 해보려고는 했으나, deadlock 현상을 보았습니다. ㅜㅡㅜ


Single 객체는 RxJava2 부터 더이상 null 을 허용하지 않겠다는 것으로 만든 객체로써, 사실 Single로 감싸게 된 맵이라도 실제 사용에는 큰 문제가 없어보입니다.


4. Math Library.


Java8 에서는 collect 나 reduce 를 이용하여 합계, 최소값, 최대값 등 통계 데이터를 구할 수 있었습니다.


RxJava2 에서는 extension 라이브러리에서 이 기능을 수행할 수 있도록 도와줍니다. 


1
2
3
4
5
// 합계
Observable.range(0100).to(MathObservable::sumInt).blockingSingle();
            
// 평균
Observable.range(0100).to(MathObservable::averageFloat).blockingSingle();
cs


5. Optional 대신 Maybe


Java8 에서는 더이상 null 을 허용하지 않겠다는 의도로 값의 존재여부를 표시할 수 있는 Optional 이란 개념이 생겼습니다. RxJava2 에서는 Maybe 를 통해서 이를 수행할 수 있습니다.


1
2
3
4
int number = 5;
 
Maybe<Integer> a = number% 5 == 0 ? Maybe.just(number) : Maybe.just(number);
a.subscribe(System.out::println);
cs


라이브러리나 플랫폼은 달라도 위에 있는 프로그래밍 패러다임의 계승은 비슷합니다.


아직 모든 기능을 알게 된 것은 아니지만, 안드로이드에서도 본격적으로 함수형 프로그래밍을 할 수 있을 것으로 보입니다.

반응형

'개발이야기 > 안드로이드' 카테고리의 다른 글

MVP 패턴을 통한 메모리 누수 관리  (0) 2016.11.24
WeakReference 테스트  (2) 2016.11.15
액티비티 개수 구하기  (0) 2016.11.15
안드로이드 DOZE 모드 만들기  (0) 2016.11.15
Posted by N'

Stream API 의 병렬스트림을 이용하여, 큰 고민 없이 병렬처리를 할 수 있음을 알 수 있었습니다.



현재 공부하고 있는 책인 [JAVA8 in Action] 에 따르면, 성능을 최적화할 때는 세 가지 황금 규칙이 있다고 합니다. 첫째도 측정, 둘째도 측정, 셋째도 측정!


병렬스트림으로 변경했을 때, 순차스트림보다 빠르다는 것을 보장할 수 있을까요? 

한번 측정을 해보겠습니다.


아래는 0~1000000 에 대한 덧셈 로직과 수행시간 결과입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
final int[] dataSet = IntStream.range(01000000).toArray();
 
// 단순한 for-loop 순차처리
{
    int sum = 0;
    for (int i = 0, size = dataSet.length; i < size; ++i) {
        sum += i;
    }
}
 
// 병렬스트림 사용.
{
    IntStream.of(dataSet).boxed().parallel().reduce(Integer::sum);
}
 
// Misure time!!
// 1.  3msecs.
// 2. 70msecs.
cs


결과는 단순한 for-loop 이 훨씬 빠르게 나왔습니다. 꼭 빠르다고만은 볼 수 없군요. ㅡㅡ^ 


병렬스트림을 사용한 예제에서는 최종연산 reduce 에서 코드를 간결하게 하기 위해(Integer::sum) 박싱(boxed) 과정을 사용하였습니다. 


알게모르게 놓치는 부분이지만 Wrapper 클래스를 사용하기 위해 하는 박싱과정은 비용이 은근히 크다고 볼 수 있습니다. 그렇기 때문에 JAVA8 에서는 원시타입을 위한 함수형인터페이스와 원시타입 전용 Stream 을 제공한다고 포스팅을 했었던 적이 있습니다.



병렬스트림의 예제를 다음과 같이 변경해보겠습니다.


1
2
3
4
5
// 병렬스트림 사용.
IntStream.of(dataSet).parallel().reduce((a, b) -> a + b);
 
// Misure time!!
// 1. 26msecs.
cs


Integer::sum 이란 이미 구현된 메소드레퍼런스 사용을 포기하고 람다로 구현하였으며, 박싱을 하지 않았습니다. 위의 예제보다 분명 시간은 빨라졌는데 단순 for-loop 보다 느립니다. 


이번에는 한 번 덧셈을 해야하는 양을 늘려보겠습니다. 현재 사용하는 IDE 인 이클립스의 힙을 늘리지 않은 상태에서 out of memory 가 나지 않는 최대량인 (0~700000000) 까지 늘려보겠습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
개수 : 2000000
1. For-loop (4 msecs)
2. Parallel   (43 msecs)
 
개수 : 25000000
1. For-loop (13 msecs)
2. Parallel   (60 msecs)
 
…….
 
개수 : 350000000
1. For-loop (122 msecs)
2. Parallel   (120 msecs)
 
개수 : 400000000
1. For-loop (152 msecs)
2. Parallel   (121 msecs)
 
개수 : 700000000
1. For-loop (243 msecs)
2. Parallel   (174  msecs)
cs


개수가 350000000 부터 비슷한 성능을 보였으며, 그 이후부터는 병렬스트림이 빠른 것을 알 수 있습니다.


즉 이 실험에서 알 수 있는 것은 작업의 분할, 멀티코어 간의 데이터 이동, 결과 병합 등 각 단계 과정의 비용이 꽤 크며, 순차로 하는 작업이 꽤 걸리는 작업일 때만 빛을 볼 수 있다는 것입니다.


두 가지 정도 병렬 처리 시, 주의해야할 문제에 대해서 언급을 했습니다.


- 반복자 내부 박싱에 주의할

(일반 비지니스로직 작성 중에서도 주의할 내용입니다. ㅡㅡ^)


- 병렬로 처리하고자 하는 일이 충분히 오래걸리는 작업인가

    (한 단위의 계산시간이 길다면, 성능개선의 가능성이 있습니다.)


이 외에, [JAVA8 in Action] 에서는 병렬스트림 사용 시, 고려해야할 사항을 다음과 같이 명시하고 있습니다.


1. 확신이 서지 않는다면 측정할 것! 


최적화를 위해서 해야할 세 가지 황금규칙을 생각하세요.


2. limit 나 findFirst 와 같은 순서에 의존하는 연산을 지양할 것.


병렬처리 자체가 반복자의 작업을 분할-정복 하는 알고리즘을 사용하는 데, 순서를 고려해야한다면 그만큼 작업(Thread의 task)간 동기화 시간이 길어지게 될 것입니다.


3. 적절한 자료구조를 사용할 것!


LinkedList 보다 ArrayList 가 좋습니다. 작업 분할을 위해서 LinkedList 는 모든 요소를 탐색해야하지만, ArrayList 는 index의 요소 단위로 탐색이 가능합니다.


작업 분할을 위한 자료구조 선택에 다음 사진을 참고하세요.


출처 : [JAVA8 in Action]


4. Stream 내의 파이프라인의 중간연산에 따라 작업 분할 성능에 영향이 있음!


일정한 크기의 Stream 의 경우 크기가 정확하기 때문에 적절하게 작업을 분리할 수 있지만, 중간에 filter 등 크기를 예측할 수 없게 만드는 중간연산이 있다면 병렬처리를 하는 것에 애로 사항을 꽃피울 수 있습니다


5. 병합과정의 비용도 고려할 것.


기껏 작업을 분할, 계산 열심히 해서 성능을 최적화 했지만, 병합과정에서 오래걸린다면 상쇄될 수 있습니다. 


6. 작업 간의 공유 변수 사용 금지!


예를 들어, 다음의 코드는 문제가 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A {
    Integer a = 0;
    
    void sum(int number) {
        this.a += number;
    }
}
 
A object = new A();
            
// 공유변수 접근.
IntStream.of(dataSet).boxed().parallel().forEach(object::sum);
 
// Measure time!!
// 526msecs.
cs


A 인스턴스의 멤버변수인 a 로 덧셈결과를 취합하고 있습니다. 이 때, 각 스레드는 공유 변수인 A.a 에 서로 접근하려하는 Race Condition 상황이 벌어질 수 있습니다. 


물론, 한 스레드가 한 변수에 접근가능하도록 내부적으로는 세마포어가 작동하는 것은 보장하지만 실험결과와 같이 비용이 크다는 것을 알 수 있습니다.



병렬스트림 사용 시, 주의사항을 다음과 같이 알아보았습니다. 


JAVA8 에서 멀티스레드 프로그래밍을 하기에 분명 Simple 해진 것은 맞고, 공짜로 병렬성을 얻었다고 하지만 이 세상에 완전한 공짜는 없다는 것을 깨닫고 갑니다.



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기


반응형
Posted by N'

JAVA8 을 공부하는 있는 책인 [JAVA8 in Action] 에서 언급되었던 내용 중 한 가지는 "공짜로 병렬성을 얻을 수 있다"는 것이었습니다. Collection 군의 데이터를 새로 추가된 API 인 Stream 의 형태를 parallel 관련 keyword 를 사용하여, 선언형 프로그래밍을 작성하면 병렬처리가 된다는 것이었죠.


아래는 병렬처리를 수행하는 간단한 예제입니다.


1
2
3
4
5
6
7
8
9
10
// Collection 클래스 군의 parallelStream 사용.
List<Integer> boxedDataList = IntStream.of(dataSet).mapToObj(Integer::new).collect(Collectors.toList());
boxedDataList.parallelStream().reduce(Integer::sum).ifPresent(System.out::println);
        
// 순차스트림 (IntStream) 을 병렬스트림으로 변
IntStream.of(dataSet).boxed().parallel().reduce(Integer::sum).ifPresent(System.out::println);
 
// 출력 결과
// 499500
// 499500
cs


위의 예제를 보면 정말 간단하다는 것을 알 수 있습니다. (Too Simple!!)

병렬 keyword 를 제외한 중간, 최종 연산 방법이 생각이 안나면, 이 곳을 참고하세요. 



간단히 리뷰를 해보면, 


1번 선언에서는 일반적으로 Collection 에서 스트림을 구하는 것 대신에 parallelStream 키워드를 통해 병렬스트림으로 변경한 후, 처리를 하고 있습니다. 


2번 선언에서는 이미 순차스트림인 상태를 parallel 중간연산을 사용하여 병렬스트림으로 변경시켰습니다.


단순히 병렬스트림으로 변경하는 것만으로 병렬처리를 할 수 있으니, 책에서 소개한 것과 같이 공짜로 병렬성을 얻었다는 말이 뻥은 아니라는 것을 알 수 있습니다. ㅡㅡ^


즉 병렬처리를 하기 위해 생각해봐야할 고민인 

사용할 스레드 개수경쟁상태(race condition), 계산된 결과들의 동기화 등이 추상화되었습니다.


 

parallel 관련 키워드 메소드를 사용하여 순차스트림을 병렬스트림으로 변경했들이,

병렬스트림을 순차스트림으로 변경할 수도 있습니다. sequencial 키워드로 말이죠. :-) 


하지만, 이러한 중간연산(parallel 과 sequencial)을 아래와 같이 특정 중간연산의 제어를 하겠다는 목적으로 여러번 사용하는 것은 부질 없습니다. ㅡㅡ^


1
2
3
4
5
6
IntStream.of(dataSet).boxed()
            .parallel()
            .filter(n -> n % 2 == 0)
            .map(n -> n + 2)
            .sequential()
            .collect(Collectors.reducing(Integer::sum)).ifPresent(System.out::println);
cs


최종적으로 선택된 sequential 만 적용되며, 위 연산은 순차상태로 계산됩니다.


하지만, 이러한 병렬처리가 무조건 성능을 끌어다 줄까요?


이 이야기는 다음 포스팅에서...




자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기



반응형
Posted by N'


JAVA8 의 등장하면서 생긴 가장 큰 변화 중 하나는 Stream API 를 통한 함수형 프로그래밍 패러다임을 사용할 수 있게 된 것입니다. 비지니스 로직 중 대부분을 SQL 과 같은 질의로 처리할 수 있게 되었기 때문에 활용을 잘한다면 성능과 간결함이라는 토끼를 모두 잡을 수 있게 된 것이죠. 


지난 포스팅까지 살펴본 Stream API 는 파이프라인식으로 여러 메소드를 연결하여 원하는 결과를 질의하는 형태였는데요. 이러한 파이프라인에 해당하는 각 메소드는 데이터를 필터하거나 타입을 변경하는 중간연산(filter, skip, map 등)과 결과를 원하는 형태로 반환하는 최종연산(foreach, collect, reduce)으로 분류할 수 있을 것 같습니다.


오늘은 그 중 최종 연산을 원하는 형태로 질의할 수 있는 방법중 하나인 collect 집중적으로 알아보려 합니다. 

(중간 연산에 대한 내용은 아래에서 참고하실 수 있습니다.)




Stream API를 포스팅 했던 대부분 예제에서는 collect 를 다음과 같이 중간연산의 결과를 List 형태로 출력하는 방법을 많이 사용했었습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Menu {
    private Integer price;
    private String name;
    
    public Menu (String name, int price) {
        this.name = name;
        this.price = price;
    }
 
    public String getName() {
        return name;
    }
    
    public Integer getPrice() {
        return price;
    }
}
 
final List<Menu> menuList = Arrays.asList(
                new Menu("고기"1200)
                , new Menu("랍스타"7600)
                , new Menu("피자"3100));
        
List<Menu> meatMenuList = menuList.stream().
            filter(menu -> menu.getName().equals("고기")).
            collect(Collectors.toList());
cs


collect 부분의 메소드를 조금 zoom-in 해서 보면, Collector 클래스를 파라미터로 받겠금 되어있는 것을 볼 수 있는데 오늘의 메인은 바로 이 Collector 입니다. :-)




1. Collector 란?


Collector 는 Stream API 의 최종연산을 어떻게 도출할 지를 추상화시킨 인터페이스입니다. 


해당 인터페이스의 각 구현 방법에 따라 원하는 최종 결과를 수행할 수 있습니다. 원하는 최종 결과를 얻기 위해 구현해야할 항목은 다음과 같습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public interface Collector<T, A, R> {
    /**
     * 새로운 결과 컨테이너를 만들기 위한 메소드
     * <pre>
     *         처음에는 빈 값이 들어가며, 연산 과정을 통해 채워진 후 결과를 출력합니다.
     * </pre>
     * 
     * @return
     */
    Supplier<A> supplier();
    
    /**
     * 컨테이너에 요소를 추가하는 메소드
     * <pre>
     *         공급자 (Supplier) 를 통해 출력해야할 컨테이너에 데이터를 추가합니다.  
     * </pre>
     * 
     * @return
     */
    BiConsumer<A, T> accumulator();
    
    /**
     * 병렬 처리(parallelStream) 시, 두 컨테이너를 병합합니다.
     * 
     * @return
     */
    BinaryOperator<A> combiner();
    
    /**
     * 최종 변환값을 결과 컨테이너 적용합니다.
     * 
     * <pre>
     *         누적된 결과 컨테이너와 최종형태가 같다면, 항등함수( f(x) = x ) 를 내보냅니다.
     * </pre>
     * 
     * @return
     */
    Function<A, R> finisher();
    
    /**
     * 컬렉터 연산 시, 방법에 대한 전략 목록을 정의합니다.
     * 
     * <pre>
     *         UNORDERED : 리듀싱 결과는 방문 순서나 누적 순서에 영향을 받지 않는다.
     *         CONCURRENT : 누적 컨테이너에 요소를 추가하는 accumulator 메소드를 동시에 호출할 수 있다.
     *         IDENTITY_FINISH : finisher 메소드가 항등함수를 내보내야하는 상황이라면, 해당 메소드를 생략하고 누적객체를 바로 사용한다.
     * </pre>
     * 
     * @return
     */
    Set<Characteristics> characteristics();
}
cs


구현된 Collector 는 위의 메소드를 일련의 논리적 순서를 수행하며 원하는 결과를 도출할 수 있습니다. 


즉 collect 를 사용하여 최종결과를 얻기 위해서는 위의 interface 를 사용자가 구현하거나, Collectors 클래스 내부의 toList() 와 같이 이미 구현된 클래스를 사용하는 방법이 있습니다.


Collectors 는 구현화된 전략 Collector 를 출력하는 팩토리로, Stream API 는 이 전략 Collector 를 바탕으로 최종연산을 할 수 있습니다.


Collectors 내부에 정의된 최종연산을 수행하는 방법이 크게 다음과 같은 세 가지 (Reducing, Grouping, Partitioning) 정도의 목적을 가지고 있다고 할 수 있습니다.



2. Reducing 


Stream API 와 관련된 포스팅 중 map 과 reduce  연산을 통하여 요약된 결과를 출력하는 map-reduce  패턴에 대해 언급을 한 적이 있습니다. map 과 reduce 를 통해 Collection 의 원하는 부분만을 원하는 결과로 출력할 수 있다는 것은 매우 매력적인 일이라 할 수 있습니다. (해당 내용은 아래 포스트에서 확인할 수 있습니다.)



Collectors 클래스에서도 이러한 요약연산을 할 수 있는 reducing 메소드를 제공하며, 이 외에도 많이 사용될 법한 통계용 전략 Collector 역시 볼 수 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
final List<Menu> menuList = Arrays.asList(
                new Menu("고기"1200)
                , new Menu("랍스타"7600)
                , new Menu("피자"3100));
                
// 총 합
menuList.stream().collect(Collectors.summingInt(Menu::getPrice));
        
// 사용자 정의 총 합
menuList.stream().collect(Collectors.reducing(0, Menu::getPrice, (a, b) -> a+b));
        
// 사용자 정의 총 합 Optional
menuList.stream().map(Menu::getPrice).collect(Collectors.reducing((a, b) -> a+b)).ifPresent(System.out::println);
        
// 연산 통계
IntSummaryStatistics statics = menuList
                                .stream()
                                .collect(Collectors.summarizingInt(Menu::getPrice));
 
System.out.println("Max : " + statics.getMax());
System.out.println("Min : " + statics.getMin());
System.out.println("sum : " + statics.getSum());
System.out.println("Average : " + statics.getAverage());
System.out.println("count : " + statics.getCount());
 
// 출력물 
// 11900
// Max : 7600
// Min : 1200
// sum : 11900
// Average : 3966.6666666666665
// count : 3
cs


Reducing 을 하는 방법은 위와 같이 열려 있으며, 비지니스 로직 구현 시 알맞은 상황따라 구현하면 될 것 같네요.



3. Grouping


SQL 로 쿼리를 만들다보면 특정 필드따라 그룹을 만들고 싶은 경우가 있으며 GROUP BY 키워드를 사용하여 다음과 같이 grouping 된 결과를 얻을 수 있습니다.


1
2
3
4
5
6
7
SELECT
    company_subject_sn
    , COUNT(member_subject_sn)
FROM
    MEMBER
GROUP BY
    company_subject_sn
cs


Collectors 의 groupingBy 메소드를 사용하면, Collection 객체에 대하여 특정조건으로 분류시키는 작업을 간단하게 만들 수 있습니다.


예를들어 아래의 조직구성원 타입의 Collection 을 회사별, 조직별로 묶는 Map 을 제작은 아래와 같습니다.


비지니스 로직을 처리하기 위한 작업 중 아래와 같이 여러 key 값을 이용하여 Map 을 구성해야할 경우가 다수 존재합니다. 알고리즘 자체는 어려운 것은 아니지만 매번 저렇게 작성을 해야한다는 것은 안타까운 일입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/**
 * 조직 정보를 담은 객체
 * 
 * @author Doohyun
 *
 */
class OrganizationMember {
    private Integer companySubjectSn;    // 회사 순번 
    private Integer memberSubjectSn;    // 구성원 순번
    private Integer organizationSn;        // 조직 순번  
    private String name;                // 이름
    
    public OrganizationMember(Integer companySubjectSn, Integer memberSubjectSn, Integer organizationSn, String name) {
        this.companySubjectSn = companySubjectSn;
        this.memberSubjectSn = memberSubjectSn;
        this.organizationSn = organizationSn;
        this.name = name;
    }
    
    public Integer getCompanySubjectSn() {
        return companySubjectSn;
    }
    public Integer getMemberSubjectSn() {
        return memberSubjectSn;
    }
    public Integer getOrganizationSn() {
        return organizationSn;
    }
    public String getName() {
        return name;
    }
}
 
List<OrganizationMember> testList = Arrays.asList(
                new OrganizationMember(511"남두현")
                , new OrganizationMember(622"윤석진")
                , new OrganizationMember(633"성지윤")
                , new OrganizationMember(744"백선기")
                , new OrganizationMember(754"황후순")
                , new OrganizationMember(561"이현우")
                , new OrganizationMember(572"태재영"));
        
HashMap<Integer, Map<Integer, List<String>>> groupingMap = new HashMap<>();
        
for (OrganizationMember organizationMember : testList) {
    final Integer companySubjectSn = organizationMember.getCompanySubjectSn();
    final Integer orgSn = organizationMember.getOrganizationSn();
            
    if (!groupingMap.containsKey(companySubjectSn)) {
        // 회사순번으로 분류
        groupingMap.put(companySubjectSn, new HashMap<>());
    }
            
    final Map<Integer, List<String>> orgMap = groupingMap.get(companySubjectSn);
    if (!orgMap.containsKey(orgSn)) {
        // 조직순번으로 분류
        orgMap.put(orgSn, new LinkedList<>());
    }
            
    // 조직순번으로 분류
    orgMap.get(orgSn).add(organizationMember.getName());
}
        
System.out.println(groupingMap.toString());
 
// 출력
// {5={1=[남두현, 이현우], 2=[태재영]}, 6={2=[윤석진], 3=[성지윤]}, 7={4=[백선기, 황후순]}}
 
cs



Collectors 팩토리에서 제공하는 groupingBy 를 사용하면 위의 문제를 보다 쉽고 가독성있게 구현할 수 있습니다. 아래 예제는 위의 기능을 Collectors.groupingBy() 를 사용하여 간결하게 작성한 내용입니다.


1
2
3
4
5
6
7
8
9
10
11
Map<Integer, Map<Integer, List<String>>> groupinParallelMap = 
                    testList
                    .parallelStream()
                    .collect(
                        Collectors.groupingBy(OrganizationMember::getCompanySubjectSn
                        , Collectors.groupingBy(OrganizationMember::getOrganizationSn, Collectors.mapping(OrganizationMember::getName, Collectors.toList()))));
        
System.out.println(groupinParallelMap.toString());
 
// 출력
// {5={1=[남두현, 이현우], 2=[태재영]}, 6={2=[윤석진], 3=[성지윤]}, 7={4=[백선기, 황후순]}}
cs


파이프라인이 조금 복잡해보이지만,  groupingBy 에서 회사조직 순번순으로 분류작업을 하였으며Stream API map 비슷한 역할을 하는 mapping  메소드를 통해 조직객체를 이름으로 변경을 했습니다.



4. Partitioning


앞서 설명한 Collectors.groupingBy() 과 비슷하게, Stream 내의 객체들을 특정 Predicate 로 분류하여 그룹화할 수 있는 기능 또한 존재합니다. Collectors.partitioningBy() 을 통해 사용할 수 있습니다.


Predicate 로 분류작업을 수행하기 때문에 반환되는 key 의 값은 Boolean(참, 거짓) 입니다. 그러므로, 결과 Map 은 최대 2 개의 그룹이 존재한다고 봐도 될 것 같습니다.


아래 예제는 회사순번이 5인 그룹과 아닌 그룹으로 분류, 또한 세부 그룹을 조직순번으로 분류한 작업입니다.


1
2
3
4
5
6
7
8
9
10
Map<Boolean, Map<Integer, List<String>>> groupinParallelMap = 
                    testList
                        .parallelStream()
                        .collect(
                            Collectors.partitioningBy((OrganizationMember v) -> v.getCompanySubjectSn() == 5
                            , Collectors.groupingBy(OrganizationMember::getOrganizationSn
                                    , Collectors.mapping(OrganizationMember::getName, Collectors.toList()))));
 
// 출력
// {false={2=[윤석진], 3=[성지윤], 4=[백선기, 황후순]}, true={1=[남두현, 이현우], 2=[태재영]}}
cs


앞의 예제와 크게 변하지 않고 단순히 파이프라인 한 개만 변할 것을 알 수 있습니다. (이게 함수형 프로그래밍의 장점이죠!!)


또한 이런 분류작업을 병렬로 하고 있음(parallelStream) 을 알 수 있습니다.



오늘 포스팅으로 Stream 에서 진행되는 중간연산과 최종연산을 수행하는 방법을 간략하게는 훑어보게 된 것 같습니다. 이러한 결과로 컨테이너 객체를 이용한 비지니스 로직이 한 결 더 유연하고 간략하며, 최적화까지 할 수 있는 여지가 생겼습니다. 


하지만 잘 사용해야 가능한 이야기겠죠? :-)



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기






반응형
Posted by N'

안녕하세요. 블로그 주인인 초보프로그래머입니당.


오랜만의 블로그 포스팅입니다.  개인적으로 바쁜 일이 있어서(곧 회사내에서 출시를 하기 때문에 버그를 열심히 잡았죠... ㅡㅡ^), 오랜만에 공부를 해보고 내용을 정리하게 되었습니다.


솔직히 블로그할 시간은 있긴 했지만, 게을러지다보니 공부하게 되는 것이 쉽지가 않네요.


하지만 책을 산 것이 아깝고, 곧 진행했던 안드로이드 프로젝트에도 함수형 프로그래밍의 결실을 시도해봐야하니(RxJava or Android N) 다시 한번 붙잡게 되었습니다.


그런 의미에서 오늘은 계속 진행하던 Stream API 의 활용에 대해 보고자 합니다. 

Stream API에 대해 처음보게 된다면 이 곳을 먼저 확인해주세요.



이전에 Stream API를 소개할 때, 컨테이너(Collection)의 활용을 질의 형태로 작성할 수 있다고 언급했었는데요. 마치 고수준 언어인 SQL을 사용하듯 말이죠. (Collection 객체를 테이블이라고 본다면, 질의를 통해 어떤 결과를 얻는다 생각하면 좋겠네요? ㅡㅡ^)


오늘은 그 중 필터링과 슬라이싱(즉 검색.. ㅡㅡ^)을 해보려 합니다.


1. 필터링

SQL의 where 절과 같은 역할입니다. Collection 객체 중 프리디케이트(Predicate)에 부합하는 객체들을 따로 추출하는 역할을 합니다. 그 메소드는 이전부터 많은 예제로 사용되었던 filter 입니다. 


몸풀기로 시작해보겠습니다.


1
2
3
4
5
6
7
8
9
List<Integer> numberList = Arrays.asList(22345688910);
 
for (Integer a : numberList.stream().filter(a -> a % 2 == 0).
                collect(Collectors.toList())) {
    System.out.println(a);
}
 
console result : [2,2,4,6,8,8,10]
 
cs


filter 메소드를 이용하여, 짝수만을 조회하였습니다. SQL로 치자면, 이정도??


1
SELECT number FROM NUMBERLIST WHERE number % 2 = 0;

cs


2. 고유 요소 필터링

위의 결과 중, 중복된 결과가 있습니다. 원하는 결과가 중복된 값이 없기를 바란다면 distinct 메소드를 사용해주면 됩니다.


1
2
3
4
5
for (Integer a : numberList.stream().filter(a -> a % 2 == 0).
                distinct().collect(Collectors.toList())) {
    System.out.println(a);
}
 
cs


생각해보면 SQL에서 DISTINCT 를 사용하여, 고유 결과를 출력할 수 있다는 것을 알고 있습니다.


1
SELECT DISTINCT number FROM NUMBERLIST WHERE number % 2 = 0;
cs


3. 결과값 제한과 스킵

보통 게시판을 만들 때, limit offset 등을 사용하여 페이징 처리를 하곤 합니다. 왜냐하면 많은 데이터를 한번에 다 보여줄 수도 없거니와, 사용도 불편하기 때문이죠.


Stream API에서는 limit offset 과 같은 역할을 해줄 수 있는 메소드 역시 가지고 있습니다.


일단 Stream을 잘 살펴보면, limit 라는 메소드를 가지고 있습니다. 아래 코드는 Stream의 결과 중, 3개를 반환하는 메소드입니다.


1
2
3
numberList.stream().filter(a -> a % 2 == 0).distinct().limit(3).forEach(System.out::println);
 
console result : [2,4,6]
cs


재미있는 점은 limit를 사용하지 않은 결과보다, limit의 파라미터 값이 크더라도 에러를 출력하지 않습니다. 이 점은 우리가 최대 몇개를 가져온다라는 비지니스 로직을 구현할 때, 방어코드를 할 필요가 없어졌음을 말합니다.


마지막으로 skip을 이용하여, 요소를 건너뛸 수 있습니다. 예를들어 3번째 결과부터 2개 출력이라 하면 이렇게 응용을 할 수 있습니다.


1
2
3
numberList.stream().filter(a -> a % 2 == 0).distinct().skip(3).limit(2).forEach(System.out::println);
 
console result : [8,10]
cs


skip역시 입력받는 파라미터에 대해 방어코드를 할 필요가 없습니다. 조건에 만족하지 못한다면 빈 배열을 출력합니다.



오늘 포스팅에서는 Stream API를 이용한 필터 및 슬라이싱하는 방법을 알아봤습니다. 


어느정도 함수형 프로그래밍의 감이 오시나요? 


오늘 포스팅으로 부터 알 수 있는 점은 함수형 프로그래밍으로 비지니스 로직을 구현 시,


1. 간편하고, 직관적인 선언형 위주의 구현


2. 방어코드 없이, 오류가 적은 코드의 구현


이라는 장점을 볼 수 있었음을 알 수 있었습니다.




자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기


반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편3 (검색과 매칭)  (0) 2017.01.18
Stream API 활용편2 (매핑)  (0) 2016.08.27
Stream과 Collection 차이  (0) 2016.08.04
Stream API  (0) 2016.08.03
람다 조합  (0) 2016.08.02
Posted by N'

지난 포스팅부터 "본격 선언형 프로그래밍을 할 수 있게 해준 Stream API" 에 대해 포스팅하고 있습니다. 

(모던해지는 자바에서 lambda와 더불어 선언형 프로그래밍이 어느정도 대세가 되지 않을까요? ㅡㅡ^)



오늘 포스팅에서는 "데이터 처리 연산을 지원하도록 추출된 연속된 요소 (JAVA8 IN ACTION 에서 인용)" 인 Stream 과 기존 Collection 의 차이에 대해 포스팅해보려 합니다. 


여기에서 연속된 요소라는 정의는 순차적으로 접근가능한 요소라는 점에서, Collection 과 Stream의 큰 차이는 데이터 저장 우선 vs 연산 우선 이라 볼 수 있을 것 같네요.


기존 Collection 은 데이터를 어떻게 잘 저장하고 접근할 것이냐에 초점을 맞췄습니다. 내부 요소에 대한 처리를 하기 위해서는 외부적으로  for-loop 를 통해 각각의 데이터에 접근하며, 비지니스 로직을 처리해야 합니다(외부 반복). 즉 어떤 처리를 위해서 Collection 내부에 모든 값을 가지고 있어야 합니다.


반면 Stream 의 경우 어떻게 처리를 할 것인가에 초점을 맞췄는데요. Stream 은 내부적으로 반복 과정을 숨겨 알아서 처리하고 결과를 어딘가에 출력하는 과정을 수행합니다. (내부 반복)  내부 반복을 사용하는 덕분에 우리는 컨테이너 처리에 대하여 순차적으로나 병렬적으로 처리를 간단하게 설정할 수 있게 되었어요. 아래 코드는 순차처리와 병렬 처리에 대한 간단한 코드입니다.


1
2
3
4
5
6
7
8
9
10
dataList.stream().filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)
        .forEach(System.out::println);        // 순차 처리
 
dataList.parallelStream().filter((a) -> a % 7 == 0).sorted((a, b) -> a.compareTo(b)).limit(4)
        .forEach(System.out::println);        // 병렬 처리
 
/*
* 위의 코드 중 병렬 처리는 의도된 결과가 나오지 않습니다. 병렬로 처리를 하기 때문에 
* parallelStream 의 사용은 "이 일이 병렬로 처리가능한가?" 를 생각해보고 사용해야합니다.
*/
cs


또한 Stream 의 처리 과정은 이론적으로 요청하는 값에 대해서만 처리를 하겠다는 핵심적인 내용이 있습니다. 이 것은 요청할 때만 처리하여, collection은 게으르게 만들겠다는 소리인데... 이 것 역시 예제로 보면 좋을 것 같아요. 


무한한 짝수를 표현해야하는 컨테이너의 문제에 대하여,


Collection은 아래과 같이 데이터를 우선적으로 만들고 있어, 소비는 할 수 없네요.


1
2
3
4
5
6
7
8
ArrayList<Integer> intList = new ArrayList<>();
for (int i = 0;; i+=2) {
    intList.add(i);
}

// 영원히 소비가 불가능합니다.
for (int i = 0, size = intList.size(); i < size; ++i){
    System.out.println(intList.get(i));
}
cs


반면 Stream 의 경우 무한한 짝수를 모두 만들기보다는 들어오는 요청에 대해서 즉시 만들어 소비하죠. (연속적인 요소가 어떻게 처리가 되는지에 대한 과정을 보기 위한 것이므로, for-loop 내부에 log 를 찍는 경우는 생각안하겠습니다.)


1
2
3
4
IntStream intList = IntStream.iterate(0, (i) -> i+2);;
intList.forEach(System.out::println);
 
// result : 0,2,4,6 ......
cs


사실 이러한 특성들은 사실 모두 비지니스 로직으로 풀어갈 수 있는 문제로 보이네요

하지만 이러한 것들을 미리 알아두는 게, 보다 더 편리하고 뻐그없겠금 사용할 수 있게 도와주지 않을까요?  




자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기

반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편2 (매핑)  (0) 2016.08.27
Stream API 활용편1 (필터와 슬라이싱)  (0) 2016.08.26
Stream API  (0) 2016.08.03
람다 조합  (0) 2016.08.02
메서드 레퍼런스  (0) 2016.08.01
Posted by N'

JAVA8 이 기존 JAVA와 달라진 부분은 단지 람다표현식이 추가된 것만 있는 것은 아닌 것 같아요. 


람다 표현식과 더불어 같이 추가된 것은 컨테이너(Collection)를 사용하는 비지니스 로직을 보다 간결하고(쉽지는 않을듯? 배워야하기 때문이죠.ㅡㅡ^ ) 성능 좋게 만들 수 있는 Stream API의 등장은 clean code 제작에 많은 도움이 될 것같습니다.


요즘 개발하고 있는 Spring 기반의 back단 작업이나 안드로이드위에서 작성하는 비지니스 로직은 DB를 껴안고 있기 때문에 컨테이너를 자주 사용하게 되고, 당연히 루프를 돌면서 이 작업, 저 작업을 하게 됩니다.


비지니스 로직에 따라 if, break, continue 등 여러 문법 등을 사용하게 되고, 때에 따라 복잡해지는 것을 작성해줘야하지만 Stream API를 사용하면 내가 무슨일을 해야한다는 것을 어떤 규칙에 따라 선언만 해주면 되는 선언형 프로그래밍을 할 수 있습니다. (SQL 질의 처럼 말이죠. SQL 질의어를 사용하면 복잡한 key-value 기반의 테이블에서 효과적으로 데이터를 찾을 수 있죠. 찾는 로직은 몰라도 되고요.)


예를 들면 다음과 같은 코드를 볼 수 있습니다. dataList 라는 컨테이너를 이용해서 같은 로직을 작성해보겠습니다.


1
2
3
4
5
6
7
8
LinkedList<Integer> dataList = new LinkedList<Integer>() {
    {
        Random random = new Random();
        for (int i = 0; i < 100++i) {
            add(random.nextInt(100));
        }
    }
};
cs


아래는 기존 JAVA8 이전 Collection을 loop돌면서 컨테이너 내부의 가장 큰 7의 배수 4개를 찾는 것입니다. (아무리 라인수를 줄일려고 해도 저는 이정도가 한계인가 봅니다. ㅜㅡㅜ)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Collections.sort(dataList, new Comparator<Integer>() {
    @Override
    public int compare(Integer arg0, Integer arg1) {
        // TODO Auto-generated method stub
        return arg1.compareTo(arg0);
    }
});
 
for (int i = 0, count = 0, size = dataList.size(); i < size && count < 4++i) {
    if (dataList.get(i) % 7 == 0) {
        System.out.println(dataList.get(i));
        ++count;
    }
}
 
cs


다음은 Stream API를 사용한 로직입니다.


1
2
dataList.stream().filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)
                .forEach(System.out::println);
cs


stream 내부 메소드를 이용해 질의를 하듯이 코드를 작성하였습니다. 정말 간단해졌죠?


이와같이 Stream API를 이용하면 단순히 비지니스 처리를 선언으로 하기 때문에 쉽게 구현할 수 있으며, 각각의 블럭 (sorted나 filter) 등이 chain 형식을 지원하기 때문에 복잡한 로직에 대해 가독성과 명확성을 확실시 해줄 수 있을 것같습니다. (즉 파이프라인 구조입니다.)


또한 내부적으로는 데이터 처리과정을 병렬화할 수 있기 때문에 성능을 더 좋게 만들 수 있습니다. 

(물론 병렬을 위한 thread 처리에 대해서는 신경쓰지 않아도 됩니다.)


이와같은 Stream API의 특징을 JAVA8 IN ACTION에서는 다음과 같이 요약하고 있습니다.


1. 선언형

더 간결하고 가독성이 좋아집니다.


2. 조립할 수 있음

유연성이 좋아집니다.


3. 병렬화

성능이 좋아집니다.


그럼 여기에서, Stream의 구조에 대해서 조금 더 살펴보죠.

Stream 을 사용하는 구조는 크게 데이터 소스를 받는 것과 비지니스 로직에 대한 각종 컨디션을 파이프라인으로 구성하기 위한 중간 연산, 구성할 파이프라인을 실행할 최종 연산정도 있습니다.


위의 작성한 코드를 살펴보면 다음과 같이 나타낼 수 있네요.


1
2
3
4
dataList.stream()        // 데이터 소스 
.filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)  // 중간 연산
.forEach(System.out::println);    // 최종 연산
 
cs


위의 역할을 살펴보면, dataList 로 부터 데이터 소스를 받아오고 있으며, 7의 배수, 내림차순, 선착순 4개 등 chain 형식으로 각종 컨디션을 연결한 중간 연산과정이 있으며, 이러한 조건의 값들을 console에 표시하겠다는 최종 연산으로 나누어짐을 알 수 있습니다. 

(Stream API에서 제공하는 보다 더 다양한 연산은 다음에 정리하여, 포스팅하도록 하겠습니다. )


이러한 Stream API를 이용한 스트림 요소의 연산은 오직 딱 한번만 사용(소비)할 수 있습니다. 예를들어 이 것은 예외를 일으킵니다.


1
2
3
4
5
6
7
Stream<Integer> stream = dataList.stream();
 
stream.filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)
        .forEach(System.out::println);    
stream.filter((a) -> a % 7 == 0).sorted((a, b) -> a.compareTo(b)).limit(10)
        .forEach(System.out::println);        // IllegalStateException 예외 발생
 
cs


아래는 예외 메시지입니다.


1
2
3
4
5
6
7
8
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline$StatelessOp.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline$2.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline.filter(Unknown Source)
    at testClass.main(testClass.java:40)
 
cs


이것으로 Stream API 에 대한 Summary 정도는 여기까지 포스팅하겠습니당. 

(나머진 필요한 것 따라 메소드를 사용해주면 되지 않을까요? 그래서 Summary 입니다. ㅡㅡ^)



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기




반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편1 (필터와 슬라이싱)  (0) 2016.08.26
Stream과 Collection 차이  (0) 2016.08.04
람다 조합  (0) 2016.08.02
메서드 레퍼런스  (0) 2016.08.01
람다의 실제 형식  (0) 2016.07.28
Posted by N'

포스트의 제목은 현재 읽고 있는 책인 "JAVA8 IN ACTION"의 첫 목차입니다.


"JAVA8 IN ACTION"에서 언급하는 프로그래밍 개념은 크게 세가지 정도로 보고 있습니다.


1. 스트림 처리 

- 이번 포스트에서 이야기 할것


2. 동작 파라미터화 

이곳을 참고 -> 2016/07/21 - [개발이야기/함수형 프로그래밍] - JAVA8 을 눈여겨봐야 하는 이유1 (메서드에 코드를 전달하는 기법)


3. 병렬성과 공유되는 가변 데이터

- 이번 포스트에서 이야기 할것


"JAVA8 을 눈여겨봐야 하는 이유 두번째 포스트" 로는 스트림 처리를 하려 합니다.


현재 보고 있는 책인 "JAVA8 IN ACTION" 에서는 스트림API에 대하여 "데이터베이스 질의 언어에서 표현식을 처리하는 병렬 연산을 지원하는 API" 라 정의하였습니다. 이는 고수준언어에서 어떠한 질의를 표현하면, 저수준에서 최적의 방법을 실행함을 의미합니다. (SQL 역시 질의어만 잘쓰면, 알아서 데이터를 빠르게 찾아주죠? ㅎㅎ)


일단 스트림에 대하여 알아봅시다.

스트림은 한번에 한개씩 만들어지는 연속적인 데이터 항목들의 모임입니다.

모든 일들은 이 스트림 단위로 끊어져 명령을 수행을 하는데,보통 유닉스에서는 파이프를 이용해 이를 연결하여 작업을 할 수 있습니다. 스트림API는 이러한 유닉스의 파이프라인을 메소드로 만들 수 있게 해주는 것이라 볼 수 있을 것 같습니다. (즉 메소드로 한층 감싸, 쉽게 파이프질을 할 수 있다 ㅡㅡ^)


그렇다면 병렬은?

일단 스트림 API를 사용하면 스레드를 사용하지 않고도 병렬성을 가질 수 있다고 합니다. "JAVA8 IN ACTION"에서는 공짜로 병렬성을 가진다는 표현을 쓰고 있습니다. stream의 처리 방식은 먼저 큰 stream 자체를 작은 stream 단계(즉 병렬이 가능한 단계)까지 분할하여 병렬적으로 처리합니다.) 아래 사진과 같이 말이죠. (JAVA8 IN ACTION에서 그림 참고)



즉 기존 collection 방식은 데이터를 어떻게 저장하고, 접근하는가에 중점을 두었다면 stream은 어떻게 데이터를 계산하는가에 중점을 두었다고 볼 수 있습니다. (즉 이러한 for문에 의한 외부반복 대신 필요 시점에 연산되는 내부반복을 통해, 거대한 데이터를 효과적으로 처리할 수 있게 되었습니다.)


스트림을 사용하기 위해서는 코드로 넘길 메소드는 동시 실행에 있어서 안전해야 합니다. 이 뜻은 메소드 자체에 상태가 없어, 실행에 있어서, thread-safe 함을 의미한다고 볼 수 있습니다. 즉 넘기는 메소드 내부에서 공유된 데이터 목록을 건드리면 문제가 있을 수 있겠죠? (예를 들어 덧셈을 하는데, 중간 녀석을 지운다던지...) 

이 것은 기존의 sychronized 라는 비싼 비용을 어느정도 대체해 줄 수 있을 것 같습니다.


Stream API에 대한 포스팅은 이 곳에서부터...




자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기






반응형
Posted by N'