ordinal 인덱싱 대신 EnumMap을 사용하라 - [6장. 열거 타입과 애너테이션(아이템37)]

  배열의 인덱스를 얻기 위해 ordinal을 쓰는 거은 일반적으로 좋지 않으니, 대신 EnumMap을 사용하도록 하자.

  아래의 2가지 상황(일차원 관계, 다차원 관계)을 통해 왜 EnumMap을 사용해야 하는지 알아보도록 하자.

 

1. 1차원 관계에서의 EnumMap

  아래의 Plant 클래스를 통해 식물의 이름(name)과 생애주기(lifeCycle)를 간단히 나타낼 수 있다.

public class Plant {
    enum LifeCycle { ANNUAL, PERENNIAL, BIENNIAL } // 한해살이, 여러해살이, 두해살이

    final String name;
    final LifeCycle lifeCycle;

    public Plant(String name, LifeCycle lifeCycle) {
        this.name = name;
        this.lifeCycle = lifeCycle;
    }

    @Override
    public String toString() {
        return name;
    }
}

  이제 정원에 심은 식물들을 배열 하나(garden)로 관리하고, 이들을 생애주기별로 묶어보고자 한다.

  ordinal()을 배열 인덱스로 사용하여 총 3개의 집합(한해살이, 여러해살이, 두해살이)을 만들고, 정원을 한 바퀴 돌며 각 식물을 해당 집합에 넣고자 한다.

    public static void main(String[] args) {
        Set<Plant>[] plantsByLifeCycle =
            (Set<Plant>[]) new Set[LifeCycle.values().length];

        for (int i = 0; i < plantsByLifeCycle.length; i++)
            plantsByLifeCycle[i] = new HashSet<>();

        Plant[] garden = new Plant[]{new Plant("A", LifeCycle.ANNUAL),
                                    new Plant("B", LifeCycle.PERENNIAL),
                                    new Plant("C", LifeCycle.BIENNIAL), 
                                    new Plant("D", LifeCycle.BIENNIAL)};

        // LifeCycle.ANNUAL -> 0
        // LifeCycle.PERENNIAL -> 1
        // LifeCycle.BIENNIAL -> 2
        // 각각의 인덱스에 식물 저장 저장
        for (Plant p : garden)
            plantsByLifeCycle[p.lifeCycle.ordinal()].add(p);

        for(int i = 0; i < plantsByLifeCycle.length; i++) {
            System.out.printf("%s: %s%n",
                Plant.LifeCycle.values()[i], plantsByLifeCycle[i]);
        }

        // 출력 결과
        // ANNUAL: [A]
        // PERENNIAL: [B]
        // BIENNIAL: [D, C]
    }

  위의 코드는 동작은 하지만 다음과 같은 문제가 있다.

1. 배열은 제네릭과 호환되지 않으니 비검사 형변환을 수행해야 하고 깔끔히 컴파일되지 않을 것이다.
2. 배열은 각 인덱스의 의미를 모르니 출력 결과에 직접 레이블을 달아야 한다.
3. 정확한 정숫값을 사용한다는 것을 여러분이 직접 보증해야 한다. (정수는 열거 타입과 달리 타입 안전하지 않기 때문이다.)

 

  EnumMap을 사용하면 배열이 실질적으로 열거 타입 상수를 값으로 매핑을 하게 된다. 훌륭한 해결책이다.
  EnumMap을 사용해 데이터와 열거 타입을 매핑하면 아래와 같다.

public static void main(String[] args) {
    Map<Plant.LifeCycle, Set<Plant>> plantsByLifeCycle =
        new EnumMap<>(Plant.LifeCycle.class);

    for (Plant.LifeCycle lc : Plant.LifeCycle.values())
        plantsByLifeCycle.put(lc, new HashSet<>());

    Plant[] garden = new Plant[]{new Plant("A", LifeCycle.ANNUAL),
        new Plant("B", LifeCycle.PERENNIAL),
        new Plant("C", LifeCycle.BIENNIAL), 
        new Plant("D", LifeCycle.BIENNIAL)};

    for(Plant p : garden)
        plantsByLifeCycle.get(p.lifeCycle).add(p);

    System.out.println(plantsByLifeCycle);

    // 출력 결과
    // {ANNUAL=[A], PERENNIAL=[B], BIENNIAL=[D, C]}
}

  ordinal()을 배열 인덱스로 사용했을 때의 문제점을 EnumMap을 사용하면 다음과 같이 해결하게 된다.

1. 안전하지 않은 형변환은 쓰지 않는다.
2. 맵의 키인 열거 타입이 그 자체로 출력용 문자열을 제공하니 출력 결과에 직접 레이블을 달 일이 없다.
3. 배열 인덱스를 계산하는 과정에서 오류가 날 가능성이 원천봉쇄된다.

  EnumMap도 그 내부에서 배열을 사용하기 때문에 성능이 ordinal을 쓴 배열에 비견된다. 내부 구현 방식을 안으로 숨겨서 Map의 타입 안전성과 배열의 성능을 모두 얻어낸 것이다.

 

  스트림을 사용하면 아래와 같이 코드를 더 간단하게 만들 수 있다.

public static void main(String[] args) {

    Plant[] garden = new Plant[]{new Plant("A", LifeCycle.ANNUAL),
        new Plant("B", LifeCycle.PERENNIAL),
        new Plant("C", LifeCycle.BIENNIAL), 
        new Plant("D", LifeCycle.BIENNIAL)};

    System.out.println(Arrays.stream(garden)
                        .collect(groupingBy(p -> p.lifeCycle)));

    // 출력 결과
    // {ANNUAL=[A], BIENNIAL=[C, D], PERENNIAL=[B]}
}

  그러나 이 코드는 EnumMap이 아닌 고유한 맵 구현체를 사용했기 때문에 EnumMap을 써서 얻은 공간과 성능 이점이 사라진다.

  그래서 아래와 같이 mapFactory 매개변수에 원하는 맵 구현체를 명시하여 EnumMap을 사용할 수 있다.

public static void main(String[] args) {

    Plant[] garden = new Plant[]{new Plant("A", LifeCycle.ANNUAL),
        new Plant("B", LifeCycle.PERENNIAL),
        new Plant("C", LifeCycle.BIENNIAL), 
        new Plant("D", LifeCycle.BIENNIAL)};

    System.out.println(Arrays.stream(garden)
        .collect(groupingBy(p -> p.lifeCycle,
            () -> new EnumMap<>(LifeCycle.class), toSet())));

    // 출력 결과
    // {ANNUAL=[A], PERENNIAL=[B], BIENNIAL=[D, C]}
}

 

 

2. 다차원 관계에서의 EnumMap

  두 열거 타입 값들을 매핑하기 위해 ordinal을 두 번이나 쓴 배열들의 배열이 있다.

  예시로는 두 가지 상태(Phase)를 전이(Transition)와 매핑하도록 구현한 프로그램이 있다.

  (액체 → 고체 = 고화, 고체 → 액체 = 액화)

public enum Phase {

    SOLID, LIQUID, GAS;

    public enum Transition {
        MELT, FREEZE, BOIL, CONDENSE, SUBLIME, DEPOSIT;

        // 행은 from의 ordinal을, 열은 to의 ordinal을 인덱스로 쓴다.
        private static final Transition[][] TRANSITIONS = {
            { null, MELT, SUBLIME },
            { FREEZE, null, BOIL },
            { DEPOSIT, CONDENSE, null }
        };

        // 한 상태에서 다른 상태로의 전이를 반환한다.
        public static Transition from(Phase from, Phase to) {
            return TRANSITIONS[from.ordinal()][to.ordinal()];
        }
    }
}

  이렇게 ordinal()을 배열 인덱스로 사용하면 문제가 많다.

1. 컴파일러는 ordinal과 배열 인덱스의 관계를 알 도리가 없다.
2. ArrayIndexOutOfBoundsException이나 NullPointerException을 던질 수 있다.
3. 상전이 표의 크기는 상태의 가짓수가 늘어나면 제곱해서 커지며, null로 채워지는 칸도 늘어난다.

  전이 하나를 얻으려면 이전 상태(from)와 이후 상태(to)가 필요하니, 맵 2개를 중첩하면 쉽게 해결할 수 있다. 안쪽 맵은 이전 상태와 전이를 연결하고 바깥 맵은 이후 상태와 안쪽 맵을 연결 하면 된다.

public enum Phase {

    SOLID, LIQUID, GAS;

    public enum Transition {
        MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
        BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
        SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID);

        private final Phase from;
        private final Phase to;

        Transition(Phase from, Phase to) {
            this.from = from;
            this.to = to;
        }

        // 상전이 맵을 초기화한다.
        private static final Map<Phase, Map<Phase, Transition>>
            m = Stream.of(values()).collect(groupingBy(t -> t.from,
                () -> new EnumMap<>(Phase.class),
                toMap(t -> t.to, t -> t,
                    (x, y) -> y, () -> new EnumMap<>(Phase.class))));

        // 한 상태에서 다른 상태로의 전이를 반환한다.
        public static Transition from(Phase from, Phase to) {
            return m.get(from).get(to);
        }
    }
}

  'Map<Phase, Map<Phase, Transition>>'은 "이전 상태에서 '이후 상태에서 전이로의 맵'에 대응시키는 맵"이라는 뜻이다.

 

  만약 여기에 새로운 상태인 플라스마(PLASMA)를 추가한다고 생각해 보자.

  그러면 상태 목록에 PLASMA를 추가하고, 전이 목록에 IONIZE(GAS, PLASMA)와 DEIONIZE(PLASMA, GAS)만 추가하면 끝이다. 간단하다.

public enum Phase {

    SOLID, LIQUID, GAS, PLASMA;

    public enum Transition {
        MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
        BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
        SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID),
        IONIZE(GAS, PLASMA), DEIONIZE(PLASMA, GAS);

        ...
    }
}

  실제 내부에서는 맵들의 맵이 배열들의 배열로 구현되니 낭비되는 공간과 시간도 거의 없이 명확하고 안전하고 유지보수하기 좋다.

 

해당 글은 Joshua Bloch 님의 'Effective Java 3/E'를 참고하였습니다.