[Java] 用 GUI 展示 EnumSet 增减元素时的内部变化（下）

背景

在 $Java$ 用 GUI 展示 EnumSet 增减元素时的内部变化（上）这篇文章里，我们借助 GUI 工具观察了 java.util.RegularEnumSet：当枚举类型中的常量数量 $nn$ n 满足 $n≤64n \le 64$ n≤64 时，EnumSet.noneOf 方法会返回 java.util.RegularEnumSet 的实例。java.util.RegularEnumSet 中用一个 long elements 字段存放位图。

本篇来看另一种情况：当枚举类型中的常量数量 $nn$ n 满足 $n>64n\gt 64$ n>64 时，EnumSet.noneOf 返回的是 java.util.JumboEnumSet 的实例 ⬇️

java 复制代码

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
    Enum<?>[] universe = getUniverse(elementType);
    if (universe == null)
        throw new ClassCastException(elementType + " not an enum");

    if (universe.length <= 64)
        return new RegularEnumSet<>(elementType, universe);
    else
        return new JumboEnumSet<>(elementType, universe);
}

JumboEnumSet 中有 elements 字段和 size 字段 ⬇️

与 RegularEnumSet 相比，有两处关键变化：

elements 字段从单个 long 变成了 long[]，数组长度是 $⌈n64⌉ \lceil \frac{n}{64} \rceil$ ⌈64n⌉，也就是 (n + 63) >>> 6
多了一个 int size 字段，add / remove 时会同步维护这个字段的值。RegularEnumSet 没有这个字段，它的 size() 是通过 Long.bitCount(elements) 实时计算的

本篇演示用的枚举类型 Tag 里有 130 个常量（C0 到 C129），所以 elements 是 long[3]，elements[2] 只用到最低的 2 位。

我们可以通过反射来观察，java.util.JumboEnumSet 中增减元素时，elements 数组的变化。

注意事项

完整代码用到了 instanceof 模式匹配，需要 JDK 16 及以上（写作本文时，我使用的是 JDK 21）
反射读取 JumboEnumSet 的私有 elements 字段，受 JDK 9+ 模块系统限制，运行时需要使用 --add-opens 选项

正文

我借助 trae 生成了可以观察 java.util.JumboEnumSet 中 elements 字段变化的代码。为了行文连贯，我把完整的代码放到完整代码这一小节里了。

如何运行

请将完整代码保存为 JumboEnumSetBehaviorDemo.java。使用如下命令可以编译它。

bash 复制代码

javac JumboEnumSetBehaviorDemo.java

编译之后，会得到以下 class 文件

JumboEnumSetBehaviorDemo.class
JumboEnumSetBehaviorDemo$BitGrid.class
JumboEnumSetBehaviorDemo$Tag.class

使用如下命令，可以运行 JumboEnumSetBehaviorDemo 中的 main 方法。

bash 复制代码

java --add-opens=java.base/java.util=ALL-UNNAMED JumboEnumSetBehaviorDemo

运行效果示例

初始效果

窗口标题里的 (130 constants, long[3]) 已经点明了本篇的关键：130 个常量，elements 数组中会有 3 个元素。

控件一共四行，左侧的小字是行标题：

factory method：EnumSet.noneOf(Tag.class)、EnumSet.allOf(Tag.class)
factory method：EnumSet.range(...)，以及它的 from/to 两个参数
java API：选择 element 之后执行 add(...)、remove(...)，以及 clear()
demo only：Reset，仅用于重置演示

蓝色按钮对应真实的 Java API 调用；深灰色表示 demo 自身的辅助控件；浅灰色表示当前不可点击。

在调用工厂方法之前，add(...)/remove(...)/clear()/Reset 都是禁用的。此时 elements 还不存在，状态面板显示 --，方格图里的取值也全是 ?。

`internal state of the EnumSet` 面板

界面中部的 internal state of the EnumSet 面板会展示 elements 字段的当前值，每次操作后都会刷新。以 EnumSet.allOf(Tag.class) 为例，该面板会显示 7 行信息（其中 elements[0] ~ elements[2] 占三行）⬇️

runtime class：set 的运行时类型，即 java.util.JumboEnumSet。这一行可以直接印证前面"背景"小节中的结论------ noneOf 返回的确实是 JumboEnumSet 的实例
elements：long[3]，这里是数组的长度
elements[0]/elements[1]/elements[2]：每个 long 元素的十六进制形式，固定 16 位，每 4 位用 _ 分组
size：set 的大小。注意这里显示的是 JumboEnumSet 维护的 size 字段，而 RegularEnumSet 会用 Long.bitCount(elements) 实时计算
set：EnumSet 中当前包含的枚举常量。130 个元素全在里面时字符串很长，面板会截断到 150 个字符并以 ... 结尾

点击 EnumSet.allOf(Tag.class) 按钮之后，会看到如下的效果 ⬇️

elements[0]/elements[1] 的 64 位全为 1；elements[2] 只有最低的 2 位为 1，因为 $130=2×64+2130 = 2 \times 64 + 2$ 130=2×64+2。

位与 `ordinal` 的对应关系

elements 依然是一个位掩码（bitmask），只不过现在按一段 64 位切成了多个 long：ordinal 为 i 的常量，位于 elements[i >>> 6] 的第 i & 63 位，也就是 elements[i / 64] 的第 i % 64 位。

对 130 个常量来说，映射关系如下 ⬇️

数组元素	存放的常量	用到的 `bit`
`elements[0]`	`C0` ~ `C63`	`bit 63` ~ `bit 0`
`elements[1]`	`C64` ~ `C127`	`bit 63` ~ `bit 0`
`elements[2]`	`C128` ~ `C129`	`bit 1` ~ `bit 0`（其余 `62` 位没有对应常量）

面板下方的方格图正是按这个规则画的：elements 中的每个元素一行，每行 64 格。

每一行都像上面的十六进制文本一样，从左到右依次是 bit 63、bit 62、......、bit 0 ，即最高位在左、最低位在右。这样方格图就能和 elements[w] 的十六进制文本直接对齐。另外，每 4 格有一道深色分隔线，正好对应十六进制里的一个数字。

以第一行为例：最左边的格子是 bit 63（即 C63），最右边是 bit 0（即 C0）；行首的 63..0 标出了这一行覆盖的 bit 范围。

第三行只用到最右边两格（C128、C129），左侧 62 格画成虚线：这些 bit 在 long 里确实存在，但没有枚举常量映射到它们。

当集合还没有创建时，格子里的取值显示为 ?；创建之后，1 表示属于集合，0 表示不属于。最近一次真正改变了状态的那一位会以橙色边框标出；如果操作没有改变任何位（例如重复 add 已存在的元素），则不会高亮任何位，上一次的高亮也会被清除。

调用工厂方法

Tag 是固定不变的 130 个常量，所以这个 demo 没有再提供"枚举类型"下拉框。三个静态工厂方法如下 ⬇️

EnumSet.noneOf(Tag.class)：得到 elements = long[3]，三个元素全为 0。分配是立即发生的，没有 ArrayList 空参构造那样的懒初始化
EnumSet.allOf(Tag.class)：elements[0]/elements[1] 都是 0xFFFFFFFF（64 位全 1），elements[2] 为 3
EnumSet.range(Tag.C60, Tag.C70)：把一段连续的 ordinal 置为 1（您也可以选择其他的起止元素）

对于 range，可以按 long 拆开理解。以 Tag.C60 到 Tag.C70 为例：

C60 在 elements[0] 的 bit 60，所以 elements[0] 的高 4 位（bit 60 ~ bit 63）被置为 1，结果是 0xF000_0000_0000_0000
C70 在 elements[1] 的 bit 6（70 - 64 = 6），所以 elements[1] 的低 7 位（bit 0 ~ bit 6）被置为 1，结果是 0x0000_0000_0000_007F
中间的 elements[2] 没有涉及，仍为 0
size 直接设为 70 - 60 + 1 = 11

JumboEnumSet 的 addRange 在跨 long 时会分三段处理：起始 word 从 from 所在位一直填到该 word 的最高位，中间整段 word 直接设为 -1，结束 word 从最低位填到 to 所在位；当 from 与 to 落在同一个 word 时，只处理这一个 word。最后直接把 size 设为区间长度。

range 参数非法时

EnumSet.range(from, to) 要求 from.ordinal() <= to.ordinal()，否则抛出 IllegalArgumentException。

例如执行 EnumSet.range(Tag.C70, Tag.C10) 时，界面会有三处反馈 ⬇️

在 Operation log 中追加一行，记录抛出的异常
在界面上方显示红色横幅，写明 from 与 to 的 ordinal
用红色边框标出 from/to 所在的控件组

此后只要成功执行一次操作，或点击 Reset 按钮，报错状态都会清除。

添加元素

选择 element 之后点击 add(...)，就能观察到被修改的那个 word 的前后变化。

下面这张图依次添加了 C0、C63、C64、C69 ⬇️

添加之后：

C0 → elements[0] 的 bit 0
C63 → elements[0] 的 bit 63（第一行最左边的格子）
C64 → elements[1] 的 bit 0（第二行最右边的格子）
C69 → elements[1] 的 bit 5

C63 和 C64 是相邻的两个常量，但它们分别落在两个 long 元素的相反两端，方格图上会看到高亮从第一行最左侧跳到第二行最右侧。

JumboEnumSet 的 add 方法如下 ⬇️

这里有两点值得注意：

先算出 eWordNum = eOrdinal >>> 6，再对第 eOrdinal 位做或运算。由于 JVM 对 long 移位的距离隐式按 64 取模，1L << 128 等价于 1L << 0，所以这句对 C128 也成立
只有当这个 word 的值真的变了，size 才会加 1；重复添加已存在的元素时 size 不变，add 返回 false

再添加 C128，就会落在 elements[2] 的范围内 ⬇️

日志里只会显示被修改的那个 long 元素，例如：

注意第三列里写的是 1L << 0 而不是 1L << 128------日志按"long 元素下标 + 该 long 元素内的 bit"来表述，和您在方格图上看到的位置直接对应。

删除元素

删除与添加是对称的：elements[ordinal >>> 6] &= ~(1L << ordinal)。以 remove(Tag.C64) 为例 ⬇️

日志里记录的是这次变化的前后值：elements[1] 0x0000_0000_0000_0021 -> 0x0000_0000_0000_0020。C64 是 elements[1] 的 bit 0，清零后整个元素从 0x21 变成了 0x20。remove(...) 操作（至多）只会影响一个 long 元素。

clear() 按钮

点击 clear() 会清空整个集合。JumboEnumSet 的 clear() 会调用 Arrays.fill(elements, 0L)，把 elements 中的所有元素置为 0，同时把 size 设为 0。

与 RegularEnumSet 直接把 elements 赋为 0 不同，这里要遍历数组逐个清零。

Operation log 面板

界面底部的 Operation log 面板会记录每一次操作。启动时的日志如下 ⬇️

text 复制代码

  add(...), remove(...) and clear() are disabled until a factory method is called
what to observe:
  EnumSet.noneOf(Tag.class) -> elements = long[3], all zero (eager allocation)
  EnumSet.allOf(Tag.class)  -> elements[0]=elements[1]=-1, elements[2]=3
  add(e)                    -> elements[ordinal >>> 6] |= 1L << ordinal
  remove(e)                 -> elements[ordinal >>> 6] &= ~(1L << ordinal)
  clear()                   -> Arrays.fill(elements, 0L); size = 0
  ordinal i lives in elements[i / 64], at bit i % 64
  grid rows are words; bits run 63 -> 0 left to right, like the hex text above

第一行提醒您：在调用工厂方法之前，add(...)、remove(...) 和 clear() 都是禁用的。从 what to observe: 开始，它列出了这个工具可以辅助您观察的几条规律，最后两行正是本篇的两个关键点：ordinal 如何拆成"word 下标 + bit 偏移"，以及方格图为什么与十六进制文本同向。

此后每执行一次操作，日志会追加一行，并自动滚动到最新一行。每一行分为三列：

该次调用的表达式，例如 add(Tag.C128)
elements 的变化。对于 add(...)/remove(...)，只显示被修改的那个 long 元素，写法为"操作前" -> "操作后"；对于 noneOf，写的是 elements = long[3], all zero；对于 allOf，则直接列出各个 long 元素的值
中括号内的一句说明，解释这次操作对位做了什么

以 allOf 和 add(Tag.C128) 为例 ⬇️