第三十三条 用EnumMap代替序数索引

之前提过，我们可能会用ordinal()方法来求索引，代替一些数组的索引，例如数种的例子，表示一些植物的归类

public class Herb {
    public enum Type { ANNUAL, PERENNIAL, BIENNIAL }
    
    private final String name;
    private final Type type;
    
    Herb(String name, Type type) {
        this.name = name;
        this.type = type;
    }
    
    @Override
    public String toString() {
        return name;
    }
}

假设植物是按照一年 两年 多年 植物进行罗列，那么需要三个集合，每个集合装自己对应的植物，把植物园中所有的植物便利一遍，按照要求放进去，书中代码

// 我添加的，假设有四种植物，分别是 aa  bb  cc  dd ，对应的的是枚举的三个类型值，分别代表 一年 两年 多年，最终打印的   // 是 一年植物的集合  二年植物的集合  多年植物的集合
Herb[] garden = {new Herb("aa", Herb.Type.ANNUAL), new Herb("bb", Herb.Type.PERENNIAL), new Herb
("cc", Herb.Type.BIENNIAL), new Herb("dd", Herb.Type.ANNUAL)};

    Set<Herb>[] herbsByType = (Set<Herb>[]) new Set[Herb.Type.values().length];
    for(int i=0; i < herbsByType.length; i++)
        herbsByType[i] = new HashSet<Herb>();
    for(Herb h : garden)
        herbsByType[h.type.ordinal()].add(h);
    for(int i=0; i < herbsByType.length; i++)
        System.out.printf("%s: %s%n", Herb.Type.values()[i], herbsByType[i]);

上述代码没问题，但有个可能出错的地方就是泛型与数组公用，我们知道，编译时泛型生效，运行时擦除泛型，如果类型错误的话，会报错的，这里比较好的是，我们没用错，那就解读一下这几行代码吧。我们创建了个Set集合类型的数组，就是说herbsByType[]数组中的每个对象都是个Set集合，并且数组中元素的个数是Herb.Type.values().length，值为3；然后便利这个数组，往这个数组里添加Set集合对象，此时 herbsByType[i] = new HashSet<Herb>(); 每个Set集合都是空集合；重点来了，整个代码中第二个增强for循环，便利了植物园的植物，也就是上面写的garden数组，有4个对象，拿第一个对象举例，Herb a = new Herb("aa",Herb.Type.ANNUAL)；增强for循环中 h 就是 Herb a，herbsByType[h.type.ordinal()].add(h); 先看h.type.ordinal()，我们知道意思就是Herb("aa", Herb.Type.ANNUAL)中的type，看最上面的代码，type即为Herb中的枚举Type，也就是Herb.Type.ANNUAL的ordinal值，那么ANNUAL是枚举中的第一个，ordinal值为0，看到这，终于明白了，herbsByType[h.type.ordinal()].add(h); 就是说 herbsByType[0].add(a)，即herbsByType[0].add(new Herb("aa", Herb.Type.ANNUAL))，然后增强for循环还有后面三个对象，同理，herbsByType[1].add(new Herb("bb", Herb.Type.PERENNIAL))，herbsByType[2].add(new Herb("cc",Herb.Type.BIENNIAL)),herbsByType[0].add(new Herb("aa", Herb.Type.ANNUAL))。我们继续往下看，看第三个增强for，意思是遍历herbsByType[]数组，Herb.Type.values()[i] 意思依次打印 Herb 枚举的对象，herbsByType[i] 意思是对应的Set集合，Set集合中装的是Herb枚举，枚举重写了toString()方法，打印的是name，即 aa bb cc dd。最终打印结果符合咱们的预期：
ANNUAL: [dd, aa]
PERENNIAL: [bb]
BIENNIAL: [cc]

上述分析了一堆，看起来也比较麻烦，书中给出了另外一种写法。之前介绍了EnumSet，属于Set集合；今天介绍EnumMap，当然属于Map集合。

Herb[] garden = {new Herb("aa", Herb.Type.ANNUAL), new Herb("bb", Herb.Type.PERENNIAL), new Herb
("cc", Herb.Type.BIENNIAL),new Herb("dd", Herb.Type.ANNUAL)};
        
    Map<Herb.Type, Set<Herb>> herbByType = new EnumMap<Herb.Type, Set<Herb>>(Herb.Type.class);
    for(Herb.Type t : Herb.Type.values())
        herbByType.put(t, new HashSet<Herb>());
    for(Herb h : garden)
        herbByType.get(h.type).add(h);
    System.out.println(herbByType);

这种写法，更安全，不必要泛型手动输入索引计算等等，也没有不安全转换，意思和上面的写法一样，只是在这里，用了Map集合代替了之前的数组，上面代码是数组中嵌套了Set集合，数组用索引来区分植物的年限；这里是用Map集合，key值为植物年限，value值为Set集合，除此之外，其他的都一样，打印结果为
{ANNUAL=[dd, aa], PERENNIAL=[bb], BIENNIAL=[cc]}

EnumMap 是属于Map集合，class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>， 看到这，我们回想之前的EnumSet，就会发现用法有异曲同工之妙，只要熟悉了Set和Map，EnumSet和EnumMap的用法也就差不多了，无外乎多了点私有的api和属性，并且记住，集合比数组安全。

如果我们碰到两次使用序数索引的数组，即二维数组，怎么变，看下面例子

public enum Phase {
    SOLID, LIQUID, GAS;
    public enum Transition {
        MELT, FREEZE, BOTL, CONDENSE, SUBLIME, DEPOSIT;
        private static final Transition[][] TRANSITIONS = {
            {null, MELT, SUBLIME},
            {FREEZE, null, BOTL},
            {DEPOSIT, CONDENSE, null}
        };
        public static Transition from(Phase src, Phase dst) {
            return TRANSITIONS[src.ordinal()][dst.ordinal()];
        }
    }
}

这段代码的意思是说，要进行二维数组组合，通过方法去取对应的值，看起来没问题，但实际上如果和第一个案例差不多，并且如果添加想新的植物，扩展不太方便，同理，可以使用EnumMap来修改，

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 src;
        private final Phase dst;
        
        Transition(Phase src, Phase dst) {
            this.src = src;
            this.dst = dst;
        }
        
        private static final Map<Phase, Map<Phase, Transition>> m =
                new EnumMap<Phase, Map<Phase, Transition>>(Phase.class);
        static {
            for(Phase p : Phase.values())
                m.put(p, new EnumMap<Phase, Transition>(Phase.class));
            for(Transition t : Transition.values())
                m.get(t.src).put(t.dst, t);
        }
        
        public static Transition from(Phase src, Phase dst) {
            return m.get(src).get(dst);
        }
    }
}

这种修改方法，有点类似第二十九条中的泛型案例，把可能出现的情况，全都列举了出来，然后把他们装进一个map集合，然后map集合嵌套集合，这个好处就是避免了数组，不用担心类型异常和数据越界等问题。在枚举中，也要记得，优先使用EnumMap和EnumSet，避免使用数组。