☌

[CAHPTER 15] Stream API 리뷰 (2) [과제 리뷰]

스터디/[STUDY] FP2017. 8. 13. 15:55

두 번째 복습 리뷰는 Stream API 의 조금 더 스마트한 사용을 위한 아래 포스팅에 대한 추가 내용입니다.


2017/07/26 - [스터디/[STUDY] FP] - [CAHPTER 15] Stream API 리뷰 (2)


Stream API 의 첫 번째 리뷰가 데이터를 필터하거나 맵핑하는 등의 중간과정을 알아보는 것이었다면, 두 번째 리뷰에서는 중간 연산의 결과를 어떻게 사용할 것인지를 다루는 결과과정을 알아보았습니다.


또한, 원시타입 Stream 역시 알아봤었습니다.


그런 의미에서 이 번 포스팅 역시, 이 시기에 진행했던 실습을 바탕으로 리뷰를 진행하도록 하겠습니다.



Q1. IntStream 실습.


원시타입 Stream 중 하나인 IntStream 을 사용해보는 실습이었습니다.

IntStream 을 이용하면, 숫자 관련된 연산들을 쉽게 처리할 수 있음을 배웠었는데요.

(이를테면, 총합, 개수, 평균, 최대값, 최소값 등등...)


그에 대한 실습으로 아래 코드를 리팩토링 해보았습니다.


1
2
3
4
5
6
7
8
9
10
int sum = 0;
 
// 짝수만 덧셈하는 로직 구현.
for (int i = 1; i <= 1000; ++i) {
    if (i % 2 == 0) {
        sum += i;
    }
}
 
System.out.println(sum);

cs


1~1000 사이의 짝수의 합을 구하는 간단한 로직입니다.

이 간단한 로직은 조금 더 간단해질 수 있을 것 같아 보입니다.


1
2
3
4
// IntStream 에서 제공하는 sum 메소드 사용.
int sumResult2 = IntStream.rangeClosed(1,1000).filter(i -> i % 2 == 0).sum();
 
System.out.println(sumResult2);
cs


많은 로직을 함수형 프로그래밍으로 리팩토링할 수 있지만, 특히 함수라는 이름답게 수학적인 로직은 보다 더욱 쉽게 리팩토링할 수 있지 않을까요? ㅎㅎ


아, 물론 알아둘 것은 기존 객체형 Stream 에서 원시타입 스트림으로 변경할 수 있다는 것 역시 알아두세요.


1
2
3
4
5
6
List<MemberVO> dataList = new MemberVO();
 
// mapToInt 사용.
dataList.stream().
    mapToInt(MemberVO::getMemberSubjectSn).
    sum();
cs


mapToInt, mapToDouble 등의 메소드는 일반 객체를 원시타입으로 변경하도록 하는 Function 을 받도록 하고 있습니다.


물론, 원시타입 stream 역시 객체 stream 으로 변경할 수 있습니다.


1
2
3
4
5
// box 형 stream 으로 변환. int -> Integer
IntStream.rangeClosed(1, 1000).boxed();
            
// 기타 객체로 변환. int -> MemberVo
IntStream.rangeClosed(1, 1000).mapToObj(number -> new MemberVo());
cs


이와 관련된 내용은 아래 포스팅에서 참고하세용 :-)


2017/01/25 - [개발이야기/함수형 프로그래밍] - Stream API 활용편5 (숫자형 스트림, 스트림 생산)



Q2. 특정 조건의 객체 찾기 (break 문 리팩토링)


일종의 흐름의 탈출이라 불릴 만한 break, continue, return 등은 goto 문과 비슷해보입니다. 


일련의 절차적 흐름에 따라 과정을 마무리 짓는 것이 아닌, 원하는 위치로 이동시키는 목적을 가진 이 keyword 들은 편의성과 별도로 유지보수에 좋지 않은 특성 때문에 사용을 지양하라고 많이 배웠었을 것입니다.


JAVA8 in Action 에서는 이런 흐름의 탈출 역시 모두 리팩토링할 수 있음을 언급했으며, 이에 대한 실습을 간단히 해보았습니다.


1
2
3
4
5
6
for (int i = 0; i < 100; ++i) {
    if (i > 50 && i % 2 == 1) {
        System.out.println(i);
        break;
    }
}
cs


위의 예제는 특정조건에 맞는 데이터가 나타나면, 데이터를 출력하고 반복을 탈출하라는 break 를 사용하고 있습니다.


이 로직은 Stream API 에서 제공하는 메소드로 리팩토링이 가능해보입니다.


1
2
3
4
5
IntStream.range(1,100).
    filter(i -> i >50).
    filter(i -> i % 2 == 1).
    findFirst().
    ifPresent(System.out::println);
cs


맞습니다. Stream API 에는 findFirst 라는 적절한 메소드가 존재하네요.

이를 이용해서, break 문을 사용하지 않으며 선언형으로 멋지게 작업을 했군요.


다른 나머지 흐름탈출 keyword 들은 어떻게 우회할 수 있을까요?


아래 포스팅을 읽어보며, 한번 익혀보세용.

또한, 이와 관련된 글들을 아래에 모두 남깁니다.


2017/01/18 - [개발이야기/함수형 프로그래밍] - Stream API 활용편3 (검색과 매칭)


2017/02/21 - [개발이야기/함수형 방법론] - 함수형 프로그래밍으로 리팩토링.



Q3. 그룹핑을 이용한 직관적인 데이터 정리


귀사에서 주로 진행하는 웹 프로젝트내에서 종단 작업을 하는 개발자들은 유지보수적인 면이나 앞단 작업자를 위해서 인터페이스 위주의 프로그래밍을 해야한다고 언급했던 적이 있었습니다.


이에 대한 글은 아래에서 참고하세용 :-)


2017/05/21 - [스터디/[STUDY] OOP] - [CHAPTER 4] 실무 활용 패턴 (중) [Adapter 패턴] + 추가내용


이에 대한 철학에 따라, 여러분은 아마 DB 에서 데이터를 조회 후 적절한 인터페이스를 설계하여 앞단 개발자에게 나머지 일을 맡길 것입니다. 


하지만, 복잡한 많은 데이터들을 엮는 것은 사실상 쉽지 않은 일입니다.


예를들면, 아래와 같은 데이터VO 들이 있다고 가정합시다.

(편의상, getter, setter 는 생략.)


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
/**
 * 구성원 정보
 *
 * Created by Doohyun on 2017. 7. 30..
 */
public class MemberVO {
    private String name;                    // 이름
    private Integer memberSubjectSn;        // 구성원순번
}
 
/**
 * 인사평가 단계 정보
 *
 * Created by Doohyun on 2017. 7. 30..
 */
public class HrAppraisalStepVO {
    private Integer hrAppraisalStepSn;     // 인사평가단계순번
    private String stepName;               // 단계명
    private Boolean useYn;                 // 사용여부
}
 
/**
 * 인사평가 종류
 *
 * Created by Doohyun on 2017. 7. 30..
 */
public class HrAppraisalKindVO {
    private Integer hrAppraisalKindSn;  // 인사평가종류순번
    private String appraisalKindName;   // 평가종류명
    private Integer displayPriority;    // 표시순서
}
 
/**
 * 인사평가 단계 종류별 점수 정보.
 *
 * Created by Doohyun on 2017. 7. 30..
 */
public class HrAppraisalStepKindResultVO {
    private Integer hrAppraisalKindSn;      // 인사평가종류순번
    private Integer memberSubjectSn;        // 구성원주체순번
    private Integer hrAppraisalStepSn;      // 인사평가단계순번
    private double score;                   // 점수
}
cs



이 네 종류의 VO 가지고 조합하여 만들어야하는 것은 아래의 VO 입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 취합 결과.
 *
 * Created by Doohyun on 2017. 7. 30..
 */
public class StepAverageResultVO {
    private String name;
 
    private List<CapabilityAverageVO> capabilityAverageVOList;
 
     /**
     * 평균점수 VO
     */
    public static final class CapabilityAverageVO {
        private String kindName;
        private Double averageScore;
        private Integer displayPriority;
 
        @Override
        public String toString() {
            return String.format("%s : %f", kindName, averageScore);
        }
    }
}
cs


생각만해도 복잡해보이는데요?


이 과정을 한번 구현해보면, 아래 정도로 구현 해볼 수 있을 것 같습니다.

(자세히는 보지 마세요..)


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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
// 인사평가단계 목록
List<HrAppraisalStepVO> hrAppraisalStepVOList = new ArrayList<>();
{
    for (HrAppraisalStepVO hrAppraisalStepVO : CompleteDao.GetInstance().getHrAppraisalStepList()) {
        // 
        if (hrAppraisalStepVO.getUseYn()) {
            hrAppraisalStepVOList.add(hrAppraisalStepVO);
        }
    }
}
 
// 인사평가종류 목록
List<HrAppraisalKindVO> hrAppraisalKindVOList = CompleteDao.GetInstance().getHrAppraisalKindList();
 
// 구성원 정보 목록.
List<MemberVO> memberVOList = CompleteDao.GetInstance().getMemberList();
 
// 인사평가단계별 종류 결과.
List<HrAppraisalStepKindResultVO> hrAppraisalStepKindResultVOList = CompleteDao.GetInstance().getHrAppraisalStepKindResultVoList();
 
 
// 평균결과 목록.
ArrayList<StepAverageResultVO> stepAverageResultVOList = new ArrayList<>();
 
// 결과목록 제작 알고리즘 정의
for (MemberVO memberVO : memberVOList) {
 
    // 데이터 삽입
    StepAverageResultVO stepAverageResultVO = new StepAverageResultVO();
    {
        stepAverageResultVO.setName(memberVO.getName());
        stepAverageResultVOList.add(stepAverageResultVO);
    }
 
    // 구성원의 역량점수 평균 목록.
    final List<CapabilityAverageVO> capabilityAverageVOList = new ArrayList<>();
 
    for (HrAppraisalKindVO hrAppraisalKindVO : hrAppraisalKindVOList) {
 
    // 단계별 종류 점수 목록.
    final List<HrAppraisalStepKindResultVO> scoreList = new ArrayList<>();
    {
        for (HrAppraisalStepVO hrAppraisalStepVO : hrAppraisalStepVOList) {
            for (HrAppraisalStepKindResultVO hrAppraisalStepKindResultVO : hrAppraisalStepKindResultVOList) {
 
                // 평가종류 잡기.
                if (memberVO.getMemberSubjectSn().intValue() == hrAppraisalStepKindResultVO.getMemberSubjectSn().intValue()
                        && hrAppraisalStepKindResultVO.getHrAppraisalKindSn().intValue() == hrAppraisalKindVO.getHrAppraisalKindSn().intValue()
                        && hrAppraisalStepVO.getHrAppraisalStepSn().intValue() == hrAppraisalStepKindResultVO.getHrAppraisalStepSn().intValue()) {
                                scoreList.add(hrAppraisalStepKindResultVO);
                        }
                }
            }
        }
 
        // 특정 종류가 모든 단계의 점수가 있어야함.
        if (scoreList.size() == hrAppraisalStepVOList.size()) {
            CapabilityAverageVO capabilityAverageVO = new CapabilityAverageVO();
            capabilityAverageVO.setKindName(hrAppraisalKindVO.getAppraisalKindName());
            capabilityAverageVO.setDisplayPriority(hrAppraisalKindVO.getDisplayPriority());
            
            // 평균점수.            
            Double average = 0.0;
            {
                for (HrAppraisalStepKindResultVO resultVO : scoreList) {
                    average += resultVO.getScore();
                }
            }
            
            average /= scoreList.size();
            capabilityAverageVO.setAverageScore(average);
            capabilityAverageVOList.add(capabilityAverageVO);
        }
    }
        
    // 역량에 따른 정렬 수행.
    Collections.sort(capabilityAverageVOList, new Comparator<CapabilityAverageVO>() {
        @Override
        public int compare(CapabilityAverageVO o1, CapabilityAverageVO o2) {
            return o1.getDisplayPriority().compareTo(o2.getDisplayPriority());
        }
    });
    
    stepAverageResultVO.setCapabilityAverageVOList(capabilityAverageVOList);
}
    
// 데이터 프린트.
{
    for (StepAverageResultVO stepAverageResultVO : stepAverageResultVOList) {
        System.out.println(String.format("%s의 점수 정보", stepAverageResultVO.getName()));
            
        for (CapabilityAverageVO capabilityAverageVO : stepAverageResultVO.getCapabilityAverageVOList()) {
            System.out.println(capabilityAverageVO);
        }
 
        System.out.println();
    }
}
 
cs


우와... 그냥, 복잡해보이네요. 

(보지마세요.. 그냥 복잡하다는 것을 보여주기 위한 것...)


여러 데이터 종류들 간의 일종의 외래키 관계 따라 데이터를 엮기 위해, n중 루프를 돌고 있습니다. 

(반복문 내의 복잡한 조건은 덤이군요....)


만약 여러 DB Model 간의 외래키의 관계로 엮어 무슨 일을 하고 싶다면, n중 반복문으로 일일이 찾아 내부에 조건을 만들기보다는 자료구조인 Map 을 이용하는 것을 추천해드립니다.


Map 에 특정 key 에 대한 그룹핑 결과를 모은 뒤, 조합 부분에서 key 기반으로 데이터를 찾아 로직에서 사용하는 것이죠...


이를테면, 특정 데이터를 찾는 for-loop 은 Map 이용하여 다음과 같이 단순화했다고 볼 수 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
// for-loop 이용.
// 반복을 통해, 특정 데이터를 찾은 뒤 행위 실행..
for (MemberVo memberVo : memberList) {
    if (memberVo.getMemberSubjectSn() == 2) {
        // 찾았다. 데이터..
        // 다음 로직 수행..
    }
}
 
// Map 을 이용.
// key 기반으로 데이터를 찾음. 단계자체가 없어져 단순화.
MemberVo memberMap = memberMap.get(2);
// 찾았다. 데이터..
// 다음 로직 수행..
cs



아래 코드는 과제를 제출해준 한 스터디 구성원에게 준 피드백입니다. 

(주석을 열심히 달았기 때문에 여기에 올려봅니다..)


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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
    /**
     * N식 백엔드 조합의 전략은 다음과 같습니다.
     *
     * - STEP1 DB 데이터 조회한 목록을 특정 사용할 key 기반 맵으로 제작.
     * - STEP2 FP 제공 메소드, 특히 filter, map 등 을 이용하여, 데이터 정리 처리. (구현 부분에서 상세하게 기술.)
     * - STEP2 를 조금 더 간략화할 수 있는 전략으로 어댑터 패턴등이 있음. (Ex. .toXXXX, fromXXX)
     *
     * 해당 방법을 꼭 확인하여, 좋은 성능의 유지보수 좋은 코드를 구현할 수 있는 역량을 키울 수 있길 바랍니다.
     * - 백엔드의 모든 서비스 로직은 아래와 같이 구현할 수 있으며, 해당 문제해결능력을 습득하면 꽤 레벨업한 자바프로그래머가 될 수 있을 것이라 생각합니다.
     *   (자료구조를 효과적으로 이용한 정보처리, 특히 Map 을 이용한 방법은 많은 것을 단순화시킬 수 있습니다.)
     */
    public void N_피드백_결과() {
 
        /**
         * 인사평가 단계 그룹
         *
         * key : 인사평가단계순번
         * value : 인사평가 단계
         */
        final Map<Integer, HrAppraisalStepVO> hrAppraisalStepVOMap = CompleteDao.GetInstance().
                                                                        getHrAppraisalStepList().
                                                                        stream().
                                                                        filter(HrAppraisalStepVO::getUseYn).
                                                                        collect(Collectors.toMap(HrAppraisalStepVO::getHrAppraisalStepSn, Function.identity()));
 
        /**
         * 인사평가 종류 그룹
         *
         * key : 인사평가종류순번
         * value : 인사평가 종류
         */
        final Map<Integer, HrAppraisalKindVO> hrAppraisalKindVOMap =  CompleteDao.GetInstance().
                                                                        getHrAppraisalKindList().
                                                                        stream().
                                                                        collect(Collectors.toMap(HrAppraisalKindVO::getHrAppraisalKindSn, Function.identity()));
 
        // 구성원 정보 목록.
        final List<MemberVO> memberVOList = CompleteDao.GetInstance().getMemberList();
 
 
        /**
         * 구성원의 단계별 종류별 점수 그룹
         *
         * - 사용하지 않는 단계는 필터되었음이 보장.
         * - 추 후, 데이터 조합에서 사용하기 쉬운 형태 순으로 그룹핑을 함.
         * - 아래의 조합 알고리즘에서는 구성원 순번, 인사평가 종류순번에 따라 점수를 분류하고, 모든 단계에 대해 점수가 존재하는지 확인한 후 평균을 구하도록 하고 있음.
         * - 그에 따라, 구성원순번 > 인사평가종류순번 > 인사평가단계순번 > 점수 순으로 그룹핑함..
         * - 이로써, 필요에 따라 원하는 부분의 그룹을 쉽게 가져올 수 있어 보임 (가져오는 부분을 STEP 이라 분류하고 주석으로 작성할 예정. 잘따라오길 바람.)
         *
         * key : 구성원 순번
         * value : {key : 인사평가종류순번, value : {key : 인사평가단계순번, value : 점수 }}
         *
         */
        final Map<Integer, Map<Integer, Map<Integer, Double>>> hrAppraisalStepKindResultMap
                = CompleteDao.GetInstance().getHrAppraisalStepKindResultVoList().
                    stream().
                    filter(vo -> hrAppraisalStepVOMap.containsKey(vo.getHrAppraisalStepSn())).
                    collect(Collectors.groupingBy(HrAppraisalStepKindResultVO::getMemberSubjectSn
                            , Collectors.groupingBy(HrAppraisalStepKindResultVO::getHrAppraisalKindSn,
                                    Collectors.toMap(HrAppraisalStepKindResultVO::getHrAppraisalStepSn, HrAppraisalStepKindResultVO::getScore))));
 
 
        // 데이터 엮기.
        final List<StepAverageResultVO> stepAverageResultVOList;
        {
            // STEP1 : 구성원 정보 목록에 따라 순회하며, 조합된 결과를 작성할 예정.
            stepAverageResultVOList = memberVOList.stream().
                                        map(memberVO -> {
                                            StepAverageResultVO resultVO = new StepAverageResultVO();
 
                                            // 구성원 정보 추가.
                                            {
                                                resultVO.setName(memberVO.getName());
                                            }
 
                                            // 정렬된 역량 평균 점수 목록.
                                            final List<CapabilityAverageVO> capabilityAverageVOList;
                                            {
                                                /**
                                                 * STEP2 : 구성원 순번에 대한, 점수 그룹을 가져옴.
                                                 *.        아래의 맵은 앞써 그룹핑한 결과에 따라 구성원 점수만 있음이 보장이 됨..
                                                 *
                                                 * 구성원이 받은 단계별 종류별 점수 그룹
                                                 *
                                                 * - Optional 을 이용한 안전한 데이터 파싱.
                                                 *
                                                 * key : 인사평가종류순번
                                                 * value : {key : 인사평가단계순번, value : 점수 }
                                                 */
                                                final Map<Integer, Map<Integer, Double>> subMap1
                                                        = Optional.ofNullable(hrAppraisalStepKindResultMap.get(memberVO.getMemberSubjectSn())).orElse(Collections.emptyMap());
 
 
                                                /**
                                                 * 맵을 이용한 key 기반 조합 방법.
                                                 *
                                                 * - key 기반 조합이기 때문에, 복잡한 알고리즘을 구현하지 않아도 됨. (필요한 정보는 맵에서 직접 추출)
                                                 * - n^m 알고리즘을 최소화할 수 있음 (성능면에서 우위)
                                                 * - filter, map 등 "유효성 체크부분"과 "정리 부분" 의 구분이 확실. (추 후, 유지보수에 괜찮은 듯)
                                                 */
                                                
                                                // 이 곳에서 할 일..
                                                // 인사평가종류에 따라 순회하며, 평균 점수 목록을 구함.
                                                capabilityAverageVOList = subMap1.keySet().stream().
                                                                            filter(hrAppraisalKindVOMap::containsKey).
                                                                            filter(hrAppraisalKindSn -> {
                                                                                // 유효성 체크.
                                                                                // 등장하면 안되는 과제에 대한 유효성 검사 부분을 이 곳에서만 구현.
 
                                                                                // STEP3 : 앞써, 구한 STEP2 에서 특정 인사평가종류의 데이터만 조회.
                                                                                //         마찬가지로, 해당 맵에는 특정 구성원의 원하는 종류의 점수만 있음이 보장..
                                                                                //.        결국 아래 맵에는 원하는 특정 종류의 단계별 점수가 있다고 볼 수 있음.
                                                                                
                                                                                /**
                                                                                 * 종류별 단계의 점수.
                                                                                 *
                                                                                 * key : 인사평가단계순번
                                                                                 * value : 점수
                                                                                 */
                                                                                Map<Integer, Double> subMap2 = subMap1.get(hrAppraisalKindSn);
 
                                                                                // 필터는 이 곳에서만 처리.
                                                                                // 점수가 비어있지 않고, 모든 단계의 점수가 있음이 보장이 되어야함.
                                                                                // 즉 위의 로직 중 조건에 맞냐는 여부를 이 곳에서만 구현함으로써 좋은 가독성을 생각해봄.
                                                                                final Boolean validYn;
                                                                                {
                                                                                    // 점수가 비어있는가?
                                                                                    Boolean isEmptyScore = subMap2.isEmpty();
 
                                                                                    // 동일한 사이즈인가?
                                                                                    Boolean isEqualsSize = (subMap2.size() == hrAppraisalStepVOMap.size());
 
                                                                                    // 모든 점수의 단계의 순번이 조회된 단계에 모두 포함되는가?
                                                                                    Boolean isContainsAllKey = subMap2.keySet().stream().allMatch(hrAppraisalStepVOMap::containsKey);
 
                                                                                    validYn = isEqualsSize && isContainsAllKey && !isEmptyScore;
                                                                                }
 
                                                                                return validYn;
                                                                            }).
                                                                            map(hrAppraisalKindSn -> {
 
                                                                                // 데이터 정리.
                                                                                // 유효성 검사를 바탕으로 나온 모든 데이터는 신뢰할 수 있음.
                                                                                // 이 곳에서는 맵을 이용한 key 기반 조합을 할 수 있음.
 
                                                                                final CapabilityAverageVO capabilityAverageVO = new CapabilityAverageVO();
                                                                                {
                                                                                    // 필터에서 구한 것과 마찬가지.
                                                                                    // 특정 단계의 평균점수를 구해야하기 때문에 다시한번 특정 구성원의 특정 종류 결과만 조회
                                                                                    //
                                                                                    // STEP3 : 앞써, 구한 STEP2 에서 특정 인사평가종류의 데이터만 조회.
                                                                                    //         마찬가지로, 해당 맵에는 특정 구성원의 원하는 종류의 점수만 있음이 보장..
                                                                                    //.        결국 아래 맵에는 원하는 특정 종류의 단계별 점수가 있다고 볼 수 있음.
                                                                                    
                                                                                    /**
                                                                                     * 종류별 단계의 점수.
                                                                                     *
                                                                                     * key : 인사평가단계순번
                                                                                     * value : 점수
                                                                                     */
                                                                                    Map<Integer, Double> subMap2 = subMap1.get(hrAppraisalKindSn);
 
 
                                                                                    HrAppraisalKindVO hrAppraisalKindVO = hrAppraisalKindVOMap.get(hrAppraisalKindSn);
                                                                                    capabilityAverageVO.setKindName(hrAppraisalKindVO.getAppraisalKindName());
                                                                                    capabilityAverageVO.setDisplayPriority(hrAppraisalKindVO.getDisplayPriority());
 
                                                                                    // 평균점수 입력.
                                                                                    {
                                                                                        subMap2.values().stream().
                                                                                                mapToDouble(Double::doubleValue).
                                                                                                average().
                                                                                                ifPresent(capabilityAverageVO::setAverageScore);
                                                                                    }
                                                                                }
 
                                                                                return capabilityAverageVO;
                                                                            }).
                                                                            sorted(Comparator.comparing(CapabilityAverageVO::getDisplayPriority)).
                                                                            collect(Collectors.toList());
                                            }
 
                                            // 역량평균 입력.
                                            resultVO.setCapabilityAverageVOList(capabilityAverageVOList);
 
                                            return resultVO;
                                        }).
                                        collect(Collectors.toList());
        }
 
        // 데이터 프린트.
        {
            stepAverageResultVOList.forEach(stepAverageResultVO -> {
                System.out.println(String.format("%s의 점수 정보", stepAverageResultVO.getName()));
                stepAverageResultVO.getCapabilityAverageVOList().forEach(v -> System.out.println(v));
                System.out.println();
            });
        }
    }
cs


즉, 위의 로직에서는 다중 for 문의 목적이 특정 외래키에 따라 원하는 데이터를 찾는 것이었습니다. 

루프의 현재 데이터에서 특정 key 에 대한 데이터를 찾기 위해 for-loop 를 돌고 있죠.


이는 for 문 내부로 들어갈 수록 챙겨야 하는 외래키의 종류는 늘어나는 로직이 되어버렸고, 코드의 복잡성을 높혔습니다.


하지만, Map 을 이용해 이 과정을 단순화함으로써 불필요하게 깊숙한 단계로 들어가지 않아도 되는 것처럼 보이네요.



하지만, Map 기반 데이터 찾기는 어느정도 약점을 가지고 있습니다.

꼼꼼하게, 해당 key가 들어있나 확인을 해줘야하는 것 처럼 보입니다.


하지만, 우리에게는 Optional 이 있으니 마음껏 데이터를 파싱할 수 있고, 대부분 로직을 비어있다는 가정하에 작성하면 강건한 프로그램이 나올 수 있습니다.

(Null 우회, Optional 의 가장 큰 혜택은 아마도 Map 이 아닐지....)


추가적으로 살펴보면, 함수형 문법을 이용하여 필터할 부분과 맵핑할 부분도 적절히 나눠져 있어, 처음 로직보다는 가독성이 좋아보입니다.


내부 주석도 잘 살펴보며, 얻어갈 수 있는 부분을 얻길 바랍니다.


이번 내용과 관련있는 포스팅은 다음과 같습니다.


2017/02/02 - [개발이야기/함수형 프로그래밍] - Collectors! 데이터를 수집해보자.


2017/03/14 - [개발이야기/함수형 방법론] - Null 대신 Optional!



Q4. Collectors 응용. 목록의 깊은 복사.


Stream API 에서 다양한 결과를 내보낼 수 있는 Collector 는 매우 강력합니다.

이런 Collector 를 배웠으니, 한번 이를 응용해보는 실습을 해보는 것이 좋을 것 같다는 생각이 들었죠...


요구사항은 다음과 같았죠.


Q3의 실습을 통해 Map 이 굉장히 좋은 자료구조라는 것을 느꼈다면, 종종 복잡한 Map 을 복사하고 싶은 욕구가 있을 수 있습니다.


하지만, 복잡한 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
// 현재 제공한 targetMap 을 깊은복사하고 싶음.
// 단순하게 맵을 새로 제작하는 것으로는 내부의 맵을 복사할 수 없음. (얕은 복사)
// 즉 하나씩 맵을 순회하면서 복사해야함을 의미.
Map<Integer, Map<Integer, Map<Integer, HrAppraisalStepKindResultVO>>> targetMap =
            CompleteDao.GetInstance().getHrAppraisalStepKindResultVoList().
                            stream().collect(
                                    Collectors.groupingBy(HrAppraisalStepKindResultVO::getMemberSubjectSn,
                                            Collectors.groupingBy(HrAppraisalStepKindResultVO::getHrAppraisalStepSn
                                            , Collectors.toMap(HrAppraisalStepKindResultVO::getHrAppraisalKindSn, Function.identity())))
);
 
        
Map<Integer, Map<Integer, Map<Integer, HrAppraisalStepKindResultVO>>> copyMap = new HashMap<>();
{
 
    for (Integer memberSubjectSn : targetMap.keySet()) {
 
        Map<Integer, Map<Integer, HrAppraisalStepKindResultVO>> subMap1 = targetMap.get(memberSubjectSn);
 
        final Map<Integer, Map<Integer, HrAppraisalStepKindResultVO>> newCopySubMap1 = new HashMap<>();
        {
            for (Integer hrAppraisalStepSn : subMap1.keySet()) {
                final HashMap<Integer, HrAppraisalStepKindResultVO> newCopySubMap2 = new HashMap<>(subMap1.get(hrAppraisalStepSn));
 
                newCopySubMap1.put(hrAppraisalStepSn, newCopySubMap2);
            }
        }
 
        copyMap.put(memberSubjectSn, newCopySubMap1);
    }
}
cs


이런 로직을 저는 Collect 메소드를 이용하여, 아래와 같이 리팩토링을 해보았죠...


자기 자신을 key 로 가지며, value 로 하위항목을 복사하는 상향식 방법이라고 할 수 있을까요? ㅎㅎ

(위에서 부터 아래를 구체화하고 있습니다.)


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
// Collector 를 이용한 깊은 복사.
final Map<Integer, Map<Integer, Map<Integer, HrAppraisalStepKindResultVO>>> copyMap;
{
    /**
     * 로직 설명.
     *
     * Collector.toMap 을 이용한 copy.
     *
     * Collector 의 toMap 제작 시,
     *
     * key 를 자기자신 (Function.identity(), 람다로 표현하면, n->n) 으로 나타내고,
     * value 를 카피할 다음 맵으로 지정합니다.
     *
     * 다음 맵에서도 마찬가지로 Collector 의 toMap 으로 자기자신을 key 로 지정하여 카피하는 전략을 이용합니다.
     *
     */
    copyMap = targetMap.keySet().
                stream().
                collect(Collectors.toMap(
                        Function.identity()
                        , memberSubjectSn -> {
                                    Map<Integer, Map<Integer, HrAppraisalStepKindResultVO>> subMap1 = targetMap.get(memberSubjectSn);
 
                                    return subMap1.keySet().
                                            stream().
                                            collect(Collectors.toMap(
                                                    Function.identity()
                                                    , hrAppraisalStepSn -> new HashMap<>(subMap1.get(hrAppraisalStepSn))
                                            ));
                                })
                        );
}
cs


이번 내용에서 가장 중요한 것은 아마 Collector 겠죠?


2017/02/02 - [개발이야기/함수형 프로그래밍] - Collectors! 데이터를 수집해보자.



이번 장에서 사실 가장 알려주고 싶었던 것은 Q3 였습니다.


Map 은 여러모로 좋은 자료구조이며, 이를 이용해서 앞서 설명한 것보다 더 다양한 것들을 해볼 수 있습니다. 

(응용할만한 것이 많죠... 위는 그냥 응용 중 하나!)


기존에 쓰던 방식을 고수하는 것도 좋지만, 이런 방법도 있구나 를 알면 꽤 좋을 듯 합니다.


무기를 택함에 있어 검만 사용해서 검을 택하는 것과,


여러 무기를 다 사용해보고 검을 택하는 것은 다르겠죠.


그럼, 이쯤에서 두 번째 복습 포스팅을 마칩니다.


복습하는 그대여, 파이팅!!! @.@

반응형

'스터디 > [STUDY] FP' 카테고리의 다른 글

[CHAPTER 17] 함수형 프로그래밍 기타 내용 [실습 리뷰]  (0) 2017.08.13
[CHAPTER 14] Stream API 리뷰 (1) [과제 리뷰]  (2) 2017.08.13
[CHAPTER 17] Optional + 디폴트 메소드 + 기타.  (0) 2017.08.03
[CAHPTER 15] Stream API 리뷰 (2)  (3) 2017.07.26
[CAHPTER 14] Stream API 리뷰 (1)  (0) 2017.07.20
Posted by N'
,

[CHAPTER 14] Stream API 리뷰 (1) [과제 리뷰]

스터디/[STUDY] FP2017. 8. 13. 14:09

안녕하세요. :-) 블로그 주인장인 "성숙한 개발을 지향하는 Ndroid" 입니다.

(잘 모르겠지만, 이 것이 필명입니다.)


드디어 함수형 프로그래밍(FP) 챕터까지 마무리함으로써, 기본적으로 목표했던 내용까지 모두 끝냈습니다.


짧았지만 진행했던 시간동안, 개인적으로 당연하게 생각했던 지식들을 다시 한번 되돌아 볼 수 있는 계기가 되었고, 이러한 여러가지 생각들을 공유할 수 있는 자리를 만들 수 있던 것은 행운이었던 것 같습니다.


진행했던 시간동안 도움이 되었고, 실제로 잘 사용만 해준다면 더할나위없이 좋은 것은 없겠죠? ㅎㅎ


그리고! 스터디를 끝냈던 주차에 [전혀, 생각 못한 기분좋은 이벤트?] 도 있어서 매우 행복했습니다. 

(하하하하하 @.@)



그렇다고, 후기같은 감성글을 남기고자 할 생각은 아닙니다!!!!


이번 포스팅 부터 세 차례동안 지난 내용에 대한 리뷰글을 남기고자 합니다.

혹시나 복습을 하고자 하는 분들이 있을지도 모르니(할지는 의문?), 그에 대한 이정표를 제공하고자 합니다.


첫번째 주제는 Stream API (1) 에서 진행했던 과제 리뷰입니다.


이 글에 대한 자료는 아래 포스팅에서 참고!


2017/07/20 - [스터디/[STUDY] FP] - [CAHPTER 14] Stream API 리뷰 (1)


과제에서는 JAVA8 이전에 작성된 간단한 코드를 Stream API 를 이용하여 리팩토링하는 시간을 가졌었습니다.


단계별로 하나씩 보도록 하죠.



Q1. Filter 를 이용한 if 절 리팩토링.


아래 코드는 컬렉션을 순회하며, 특정 조건에 맞는 자료를 출력하는 로직입니다.


1
2
3
4
5
6
7
8
9
// 구성원 정보 출력.
List<MemberVo> memberVoList = MemberService.GetInstance().selectMemberList();
 
for (MemberVo memberVo : memberVoList) {
    // 구성원 순번이 3 이하인 정보만 출력.
    if (memberVo.getMemberSubjectSn() < 3) {
        System.out.println(String.format("이름 : %s, 나이 : %d", memberVo.getName(), memberVo.getAge()));
    }
}
cs

비교적 간단해보이는 이 로직은 내부반복을 이용하는 Stream API 에서 filter 키워드를 이용하여 리팩토링할 수 있었습니다.

1
2
3
4
 MemberService.GetInstance().selectMemberList().
     stream().
     filter(memberVo -> memberVo.getMemberSubjectSn() < 3).
     forEach(memberVo ->  System.out.println(String.format("이름 : %s, 나이 : %d", memberVo.getName(), memberVo.getAge())));
cs


위의 코드나 아래 코드나 사실 큰 차이는 없어보이지만, 

함수형으로 작성된 코드는 분기조건(filter)과 실행행위(foreach)의 로직을 분리하고 있습니다.


이는 꽤 복잡한 로직에서 생각보다 매력적으로 다가올 수 있을 것처럼 보입니다.


관련 내용은 아래 포스팅에서 확인할 수 있습니다. :-)


2016/08/26 - [개발이야기/함수형 프로그래밍] - Stream API 활용편1 (필터와 슬라이싱)




Q2. 정렬과 결과의 개수 제한 로직 리팩토링.


이번 문제에서는 Stream API 의 조금 더 기능을 써보고자 진행했던 내용입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 구성원 정보 출력.
List<MemberVo> memberVoList = MemberService.GetInstance().selectMemberList();
 
// 나이 순으로 내림차순 정렬,
Collections.sort(memberVoList, new Comparator<MemberVo>() {
    @Override
    public int compare(MemberVo o1, MemberVo o2) {
        return o2.getAge().compareTo(o1.getAge());
    }
});
 
// 구성원 목록이 존재할 경우, 나이가 가장 많은 사람의 이름을 출력.
if (!memberVoList.isEmpty()) {
    MemberVo memberVo = memberVoList.get(0);
 
    System.out.println(String.format("나이가 가장 많은 사람은 ? %s", memberVo.getName()));
}
cs


Q1 과 비교하여, 특정 조건에 맞게 정렬도 해야하며, 정렬된 결과에 따라 딱 한개만 결과가 나오도록 해야하는군요.


하지만, Stream API 에는 다양한 파이프라인 메소드들이 존재하니 이 것 역시 쉽게 해결할 수 있을 것입니다.


1
2
3
4
5
MemberService.GetInstance().selectMemberList().
    stream().
    sorted((o1, o2) -> o2.getAge().compareTo(o1.getAge())).
    findFirst().
    ifPresent(memberVo -> System.out.println(String.format("나이가 가장 많은 사람은 ? %s", memberVo.getName())));
cs


Stream API 에서 지원하는 sort 메소드를 이용하여 정렬하였고, 첫 번째 데이터를 찾기 위해 findFirst 를 사용했습니다.


findFirst 의 결과는 있을 수도 없을 수도 있기 때문에, Optional 형태로 출력함을 잊지마세용.

(현재 케이스에서는 MemberService::selectMemberList 의 결과가 빈 리스트일 수 있음.)


여기서 또한 주목할 점은 의무체인 Lambda 를 이용해볼 수 있다는 것입니다.

sort 의 비교구문은 현재 Lambda 로 되어있지만, Comparator 에서 제공하는 팩토리 메소드를 이용하면 조금 더 직관적으로 변경할 수 있습니다.


1
2
3
4
5
6
 // 나이를 이용하여, 내림차순 정렬.
Comparator<MemberVo> comparator1 = (MemberVo o1, MemberVo o2) -> o2.getAge().compareTo(o1.getAge());
            
// Comparator 의 comparing 으로 어떤 값을 이용하여 정렬할지 지정.
// reversed 메소드를 이용하여 내림차순.
Comparator<MemberVo> comparator2 = Comparator.comparing(MemberVo::getAge).reversed();
cs


어때요? 보다 직관적이고 수정하기 쉽겠죠?


해당 내용은 아래 포스팅에서 확인할 수 있습니다. :-)


2016/08/02 - [개발이야기/함수형 프로그래밍] - 람다 조합


2016/08/26 - [개발이야기/함수형 프로그래밍] - Stream API 활용편1 (필터와 슬라이싱)


2017/01/18 - [개발이야기/함수형 프로그래밍] - Stream API 활용편3 (검색과 매칭)


2017/03/14 - [개발이야기/함수형 방법론] - Null 대신 Optional!



Q3. 맵핑 튜토리얼.


Stream API 에서 가장 많이 사용한다고 볼 수 있는 mapping(사상화)에 대한 튜토리얼입니다.

map 을 이용하면, 간단하게 컬렉션의 제네릭 타입을 목적에 맞게 변경시킬 수 있습니다.


예제를 한번 보죠. 아래 코드는 간단합니다. 

구성원목록에서 지역을 추출한 뒤, 오름차순에 따라 정렬 후 콘솔 출력을 하고 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 구성원 정보 출력.
List<MemberVo> memberVoList = MemberService.GetInstance().selectMemberList();
 
// red-black tree 알고리즘 따라, 이 곳에 넣은 정보는 자동으로 정렬이 됨.
final TreeSet<String> treeSet = new TreeSet<>();
{
    for (MemberVo memberVo : memberVoList) {
        treeSet.add(memberVo.getLocation());
    }
}
 
for (String location : treeSet) {
    System.out.println(location);
}
cs


아래 코드는 map 메소드를 이용하여, 아래와 같이 리팩토링할 수 있습니다.


1
2
3
4
MemberService.GetInstance().selectMemberList().stream().
    map(MemberVo::getLocation).
    sorted().
    forEach(System.out::println);
cs


정말 간단해서 좋군요.

map 에 치환 Function 만 적절(MemberVo -> String)하게 넣어주면, 모든 것이 해결! ^^


해당 내용은 아래에서 확인할 수 있습니다.


2016/08/27 - [개발이야기/함수형 프로그래밍] - Stream API 활용편2 (매핑)



Q4. FlatMap 을 이용한 Inner Join 패턴 구현.


특정 Stream 을 다른 Stream 으로 변경할 수 있는 flatMap 을 이용하여, Inner join 과 같은 패턴을 구현해 볼 수 있습니다.


이를 활용해 보기 위한 예제는 아래와 같았습니다.


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
// 구성원 정보 출력.
List<MemberVo> memberVoList = MemberService.GetInstance().selectMemberList();
 
// 코멘트 정보 출력.
List<CommentVo> commentVoList = MemberService.GetInstance().selectMemberCommentList();
 
final ArrayList<MemberCommentVo> memberCommentVoList = new ArrayList<>();
{
    // 구성원 정보와 코멘트 정보를 엮는다.
    for (MemberVo memberVo : memberVoList) {
        for (CommentVo commentVo : commentVoList) {
            if (memberVo.getMemberSubjectSn().intValue() == commentVo.getMemberSubjectSn().intValue()) {
                MemberCommentVo memberCommentVo = new MemberCommentVo();
                memberCommentVo.setMemberSubjectSn(memberVo.getMemberSubjectSn());
                memberCommentVo.setComment(commentVo.getComment());
                memberCommentVo.setName(memberVo.getName());
 
                memberCommentVoList.add(memberCommentVo);
            }
        }
    }
 
    // 이름으로 정렬.
    Collections.sort(memberCommentVoList, new Comparator<MemberCommentVo>() {
        @Override
        public int compare(MemberCommentVo o1, MemberCommentVo o2) {
            return o1.getName().compareTo(o2.getName());
        }
    });
}
 
// 오직 세개까지만 처리.
for (int i = 0, size = memberCommentVoList.size(); i < 3; ++i) {
    MemberCommentVo memberCommentVo = memberCommentVoList.get(i);
 
    System.out.println(String.format("%s : %s", memberCommentVo.getName(), memberCommentVo.getComment()));
}
cs


두 타입의 목록에서 구성원순번이 같은 데이터 끼리 엮어 새로운 리스트를 만듭니다.

또한 새로운 목록을 이름 순으로 정렬하고 있네요.

게다가 3개 까지만, 출력하도록 제한하고 있습니다.


이 로직을 구현하기 위해서 꽤 코드가 길어졌군요.


하지만, 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
// 구성원 정보 출력.
List<MemberVo> memberVoList = MemberService.GetInstance().selectMemberList();
 
// 코멘트 정보 출력.
List<CommentVo> commentVoList = MemberService.GetInstance().selectMemberCommentList();
 
memberVoList.stream().
    flatMap(memberVo -> {
        // flatMap 은 현재 stream 에서, 다른 타입의 stream 으로 변경할 수 있게 해줌.
        return commentVoList.stream().
                    filter(commentVo -> {
                        // 구성원 순번이 같은 것끼리만 필터하도록 처리!
                        return memberVo.getMemberSubjectSn().equals(commentVo.getMemberSubjectSn());
                    }).
                    map(commentVo -> {
                        // 취합 데이터 생산.
                        MemberCommentVo memberCommentVo = new MemberCommentVo();
                        memberCommentVo.setMemberSubjectSn(memberVo.getMemberSubjectSn());
                        memberCommentVo.setComment(commentVo.getComment());
                        memberCommentVo.setName(memberVo.getName());
 
                        return memberCommentVo;
                    });
                }
    ).
    sorted(Comparator.comparing(MemberCommentVo::getName)).
    limit(3).
    forEach(memberCommentVo -> String.format("%s : %s", memberCommentVo.getName(), memberCommentVo.getComment()));
cs


flatMap 구문을 보면, 특정 구성원 데이터(memberVo)에 대하여 새로운 Stream 를 출력하도록 하는 Function 을 받도록 되어 있습니다.

이에 따라, CommentVoList 에서는 구성원 순번에 따라 알맞은 데이터를 filter 하고 mapping 하는 Stream 을 넘기도록 하고 있습니다.

나머지 구문은 이름만 봐도 무슨 일을 하는지 알 수 있겠죠? :-)

- sorted : 구성원 이름에 따라 정렬

- limit : 3개 제한

- foreach : 데이터를 이용한 행위 구현.

해당 내용은 아래에서 확인할 수 있습니다.

2016/08/26 - [개발이야기/함수형 프로그래밍] - Stream API 활용편1 (필터와 슬라이싱)


2016/08/27 - [개발이야기/함수형 프로그래밍] - Stream API 활용편2 (매핑)



Stream API 에 대한 첫 번째 튜토리얼은 꽤 심박하지만, 강력했던 것 같습니다.


특히, 내부반복을 이용한다는 측면에서 많은 비지니스 로직을 [필터,맵핑,결과]등 여러 단계를 명시적으로(반 강제적 ㅡㅡ^) 나눌 수 있기 때문에 유지보수성에 있어서 꽤 괜찮은 코드들을 작성할 수 있을 것 같습니다.


조금만 익숙해지면, 실무에서 이를 적용하는 것은 어렵지 않을 것입니다. :-)


그럼, 이 쯤에서 이번 포스팅을 마칩니다.


복습하는 그대여, 파이팅!!! @.@

반응형

'스터디 > [STUDY] FP' 카테고리의 다른 글

[CHAPTER 17] 함수형 프로그래밍 기타 내용 [실습 리뷰]  (0) 2017.08.13
[CAHPTER 15] Stream API 리뷰 (2) [과제 리뷰]  (2) 2017.08.13
[CHAPTER 17] Optional + 디폴트 메소드 + 기타.  (0) 2017.08.03
[CAHPTER 15] Stream API 리뷰 (2)  (3) 2017.07.26
[CAHPTER 14] Stream API 리뷰 (1)  (0) 2017.07.20
Posted by N'
,
Daum / Designed by i2i Labs

티스토리툴바