EnumMap 初始化方式升级：从循环到 Stream 演进

在Java编程中，当我们需要将枚举类型作为键来存储数据时，EnumMap是比HashMap更优的选择。EnumMap是专门为枚举键设计的Map实现，它在内部使用数组存储值，因此具有极高的性能，并且是类型安全的。在处理涉及枚举状态转换等复杂映射场景时，EnumMap的优势尤为突出。

考虑一个典型的场景：定义物质的不同相（固态、液态、气态）及其相互之间的转换。我们可以用一个外部枚举Phase表示物质的相，用一个嵌套枚举Transition表示相之间的转换。每个Transition实例都包含一个源相（from）和一个目标相（to）。我们的目标是构建一个映射，能够通过源相和目标相快速查找对应的Transition实例。例如，从液态到固态的转换是“凝固”（FREEZE）。

传统初始化方法：《Effective Java》第二版实践

在Java的早期版本，或者在不倾向于使用Stream API的场景下，初始化复杂的EnumMap通常采用显式的循环结构。这种方法通常涉及两层循环：外层循环用于初始化每个枚举键对应的内部EnumMap，内层循环则遍历所有转换实例，将其放入对应的映射中。

以下是《Effective Java》第二版中可能采用的初始化方式：

// Using a nested EnumMap to associate data with enum pairs
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);

        final Phase src; // 源相
        final Phase dst; // 目标相

        Transition(Phase src, Phase dst) {
            this.src = src;
            this.dst = dst;
        }

        // 初始化相转换映射
        private static final Map> m =
            new EnumMap>(Phase.class);
        static {
            // 第一步：为每个源相初始化一个内部的EnumMap
            for (Phase p : Phase.values()) {
                m.put(p, new EnumMap(Phase.class));
            }
            // 第二步：遍历所有转换实例，将其放入对应的内部EnumMap中
            for (Transition trans : Transition.values()) {
                m.get(trans.src).put(trans.dst, trans);
            }
        }

        public static Transition from(Phase src, Phase dst) {
            return m.get(src).get(dst);
        }
    }
}

这种方法的优点是逻辑清晰、直观易懂。通过分步操作，我们可以清楚地看到Map是如何被构建和填充的。对于Java初学者或习惯命令式编程风格的开发者来说，这种方式的可读性较高。然而，其缺点是代码相对冗长，尤其是在映射关系更加复杂时，可能需要更多的循环和条件判断。

现代初始化方法：《Effective Java》第三版实践

随着Java 8引入Stream API，集合操作变得更加声明式和函数式。对于EnumMap的初始化，尤其是需要根据多个属性进行分组和映射的场景，Stream API提供了一种更为简洁高效的解决方案。

以下是《Effective Java》第三版中采用的Stream API初始化方式：

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>
         m = Stream.of(values()).collect(groupingBy(t -> t.from, // 按源相分组
         toMap(t -> t.to, t -> t, // 内部Map：键为目标相，值为转换实例
            (x, y) -> y,  // 合并函数：在键冲突时选择第二个值（此处不会发生冲突，但必须提供）
            () -> new EnumMap<>(Phase.class)))); // 内部Map的工厂：确保生成EnumMap

      public static Transition from(Phase from, Phase to)  {
         return m.get(from).get(to);
      }
   }
}

这段代码利用了Stream.of(values())将所有Transition实例转换为一个流。接着，collect()方法结合了两个重要的收集器：

1. groupingBy(t -> t.from)：这是一个外层收集器，它根据Transition实例的from（源相）属性进行分组，生成一个Map>。但在这里，它与第二个收集器结合使用。
2. toMap(t -> t.to, t -> t, (x, y) -> y, () -> new EnumMap<>(Phase.class))：这是groupingBy的下游收集器，它作用于每个分组（即每个Phase对应的Transition列表）。
   • t -> t.to：指定内部Map的键是Transition实例的to（目标相）。
   • t -> t：指定内部Map的值是Transition实例本身。
   • (x, y) -> y：这是一个合并函数。当出现键冲突时（即同一个源相到同一个目标相存在多个Transition实例时），它定义了如何解决冲突。在此特定场景下，每个源相到目标相的转换是唯一的，因此这个合并函数实际上不会被调用，但toMap方法要求在提供Map工厂时必须提供此参数。
   • () -> new EnumMap<>(Phase.class)：这是一个Map工厂，它确保了groupingBy生成的内部Map是EnumMap类型，而不是默认的HashMap，从而保留了EnumMap的性能优势。

这种Stream API的初始化方式显著减少了代码行数，代码更加紧凑和声明式。它表达了“我们想要根据源相分组，然后在每个组内，根据目标相映射到转换实例”的意图，而不是“先创建这个，再遍历那个来填充”。

两种方法的对比与选择

• 可读性与简洁性： 传统循环方法在逻辑上更显式，对于不熟悉Stream API的开发者来说可能更容易理解。Stream API方法则更加简洁和函数式，一旦掌握其模式，就能快速理解其意图。
• 性能： 对于枚举类型，EnumMap本身就提供了优异的性能。两种初始化方法在最终的运行时性能上差异不大，主要体现在初始化阶段。Stream API在内部优化上可能略有优势，但对于大多数应用而言，这不是决定性因素。
• 代码风格与维护： Stream API代表了现代Java的编程范式，使用它可以使代码更具表达力。然而，如果团队成员对Stream API不熟悉，过度使用可能会降低代码的可维护性。

总结

无论是采用传统的显式循环还是现代的Stream API，核心思想都是为了高效地初始化EnumMap，以实现枚举对之间的复杂映射。在实际项目中，选择哪种初始化方法应基于以下考量：

1. 团队熟悉度： 如果团队成员普遍熟悉Stream API，那么采用Stream API可以提升代码质量和简洁性。反之，传统循环可能更安全。
2. 复杂性： 对于简单的映射，两种方法差异不大。但对于涉及多层分组、过滤或转换的复杂映射，Stream API往往能提供更优雅、更紧凑的解决方案。
3. 项目规范： 遵循项目或团队既定的代码风格和规范。

总之，EnumMap是处理枚举键映射的强大工具，而Java语言的发展为我们提供了多种初始化其复杂结构的方式。理解并灵活运用这些方法，将有助于我们编写出更高效、更可维护的Java代码。