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

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

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

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

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

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

Q1. IntStream 실습.

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

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

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

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

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

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

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

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

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

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

List<MemberVO> dataList = new MemberVO();
 
// mapToInt 사용.
dataList.stream().
    mapToInt(MemberVO::getMemberSubjectSn).
    sum();

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

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

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

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

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

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

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

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

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

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

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

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

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

맞습니다. 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 는 생략.)

/**
 * 구성원 정보
 *
 * 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;                   // 점수
}

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

/**
 * 취합 결과.
 *
 * 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);
        }
    }
}

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

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

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

// 인사평가단계 목록
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();
    }
}
 

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

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

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

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

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

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

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

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

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

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

    /**
     * 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();
            });
        }
    }

즉, 위의 로직에서는 다중 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 을 깊은복사하기 위해서는 아래와 같은 로직이 필요할 수 있습니다.

// 현재 제공한 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);
    }
}

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

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

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

// 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))
                                            ));
                                })
                        );
}

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

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

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

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

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

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

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

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

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

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