打开枚举集

Question

老方法，如果我们想在一些复杂的位掩码上switch，我们可以很容易地这样做（我头脑中的一个随机示例只是为了演示这个问题）：

private static final int   MAN = 0x00000001;
private static final int WOMAN = 0x00000002;
// ...alive, hungry, blind, etc.
private static final int  DEAD = 0xFF000000;

public void doStuff(int human) {
    switch (human) {
    case MAN | DEAD:
        // do something
        break;
    // more common cases
    }
}

现在，由于我们使用enums 和EnumSets，我有时想做类似的事情：

enum Human {
    MAN, WOMAN, DEAD; // etc.
}

public void doStuff(EnumSet human) {
    switch (human) {
    case Human.MAN | Human.DEAD:
        // do something
        break;
    // more common cases
    }
}

这不起作用，因为我们只能在 int、enum 或 String 值上使用 switch。在这一点上，我意识到这是做不到的，即使 enum 值基本上只是隐藏的整数。但我喜欢四处挖掘，该功能看起来非常有用，所以：

private static final EnumSet<Human> DEAD_MAN = EnumSet.of(Human.MAN, Human.DEAD);

public void doStuff(EnumSet human) {
    switch (human) {
    case DEAD_MAN:
        // do something
        break;
    // more common cases
    }
}

仍然没有运气。 Knowing the trick for switch on Strings 并且 EnumSets 实际上是 64 位字段（或它们的数组），我也会尝试：

    switch (human.hashCode()) {
    case (Human.MAN.hashCode() | Human.DEAD.hashCode()):
        // do something
        break;
    // more common cases
    }

认为当 Human hashCode() 被正确实施以提供一致的结果时，它可以工作。没有：

java.lang.Error: 未解决的编译问题：case 表达式必须是常量表达式

---

现在，我想知道为什么不可能这样做。我一直认为 Java 中的 enums 和 EnumSets 是那些老式位域的合适替代品，但在这里似乎新方法无法处理更复杂的情况。

与switch 的任何一种可能性相比，正确的 解决方案有点糟糕：

public void doStuff(EnumSet human) {
    if (human.contains(Human.MAN) && human.contains(Human.DEAD)) {
        // do something
    } else {
        // more common cases
    }
}

特别是自从Strings上引入switch之后，我相信switch上EnumSets上至少有两种可能的实现方式：

1. 在case (Human.MAN | Human.DEAD) 表达式中，简单地使用编译时类型检查和ordinal() 而不是枚举本身。
2. 使用the same trick as for Strings。
   • 在编译时，计算枚举值的hashCode() name（可能还有一些额外的东西 - 枚举中的值的数量，ordinal() 等 - 一切都是从编译时开始是静态和常量）。是的，这意味着将 hashCode() 更改为 EnumSet 类或 Enum 类。
   • 使用而不是枚举本身

现在，是否有任何我没有考虑到的严重障碍（我可以想出一些，都可以轻松克服），这会导致无法轻松实施？还是说这确实是可能的，但对于 Oracle 来说还不足以实现它，因为它不经常使用，这是对的吗？

---

_{另外，让我声明这是一个纯粹的学术问题可能没有一个好的答案（不知道，否则我不会问）。如果它被证明是无法回答的，我可能会将其设为社区 wiki。但是，我在任何地方都找不到答案（甚至任何人都在讨论它），所以就这样吧。}

Answer 1

在 Java 和面向对象的世界中，您将在 Object 上拥有带有 setter 和 getter 的类，并且您会使用它们

public void doStuff(Human human) {
    if(human.isDead()) {
       if(human.isMale()) {
           // something
       } else if (human.isFemale()) {
           // something else
       } else {
           // neither
       }
    }
}

注意：switch 不是一个好主意，因为它只需要完全匹配。例如case MAN | DEAD: 不会匹配 MAN | HUNGRY | DEAD 除非你只想匹配那些在死前不饿的人。 ;)

---

我会看到你的“绝对足够”的基准，并为你提出另一个有缺陷的基准，它“表明”它需要一个时钟周期的一小部分（因为你想知道，这很难相信）

public static void main(String... args) {
    Human human = new Human();
    human.setMale(true);
    human.setDead(true);
    for(int i=0;i<5;i++) {
        long start = System.nanoTime();
        int runs = 100000000;
        for(int j=0;j< runs;j++)
            doStuff(human);
        long time = System.nanoTime() - start;
        System.out.printf("The average time to doStuff was %.3f ns%n", (double) time / runs);
    }
}

public static void doStuff(Human human) {
    if (human.isDead()) {
        if (human.isMale()) {
            // something
        } else if (human.isFemale()) {
            // something else
        } else {
            // neither
        }
    }
}

static class Human {
    private boolean dead;
    private boolean male;
    private boolean female;

    public boolean isDead() {
        return dead;
    }

    public boolean isMale() {
        return male;
    }

    public boolean isFemale() {
        return female;
    }

    public void setDead(boolean dead) {
        this.dead = dead;
    }

    public void setMale(boolean male) {
        this.male = male;
    }

    public void setFemale(boolean female) {
        this.female = female;
    }
}

打印

The average time to doStuff was 0.031 ns
The average time to doStuff was 0.026 ns
The average time to doStuff was 0.000 ns
The average time to doStuff was 0.000 ns
The average time to doStuff was 0.000 ns

在我的机器完全优化之前，这是 0.1 个时钟周期。

Answer 2

执行以下操作（根据您的示例）：

enum Human {
    MAN, WOMAN, DEAD; // etc.
}

public void doStuff(Human human) {
    switch (human) {
        case MAN:
        case DEAD:
            // do something
            break;
        // more common cases
    }
}

如果你想要EnumSet，那么你不能使用switch，应该将它重构为if

public void doStuff(EnumSet<Human> human) {
    if( human.containsAll(EnumSet.<Human>of(Human.MAN, Human.DEAD) {
            // do something
    }
}

后一种变体将在内部进行按位比较。

Answer 3

使用EnumSet的Set方法怎么样。

private static final EnumSet<Human> DEAD_MAN = 
  EnumSet.of(Human.MAN, Human.DEAD);

public void doStuff(EnumSet human) {
    if ( human.containsAll( DEAD_MAN ) )
    {
            // do something
            break;
    }
    else
    {
        // more common cases
    }
}

实际上，EnumSet 对Set 接口方法的实现非常高效，下面是您正在寻找的位域比较。