如何隐式地将枚举映射到整数 我知道我没有使用正确的术语，但基本上我想把这个代码用C++来移植到java public enum Packets { // Maps enums to integers 0-3 PACKET_NONE = 0, PACKET_SYNC, PACKET_EXPECT_TO_RECEIVE, PACKET_AVAIL_1, // Maps enums to integers 13-16 PACKET_FILL = 13, PACKET_GLASS, PACKET_FILLi, PACKET_GLASSi }

我想显式地将一个枚举映射到一个int，然后让每个后续的枚举隐式地映射到该整数的下一个增量（或者尽可能接近此C代码的某个解决方案）。

在Java中，如果您正在寻找值，您可以为枚举赋值。它将如下所示：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3);

    private int value;

    Packets(int value){
        this.value = value;
    }

    public int getValue(){
        return value;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(14),
    PACKET_FILLI(15),
    PACKET_GLASSI(16);

    private final int id;

    private MyEnum(final int id) {
        this.id = id;
    }

    public final int getId() {
        return index;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets(){
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id){
        this.id = id;
    }

    public static void initIds(){
        for(Packets p : Packets.values()){
            if(p.getId()==-1){
                if(p.ordinal()==0){
                    p.setId(0);
                }else{
                    p.setId(Packets.values()[p.ordinal()-1].getId()+1);
                }
            }
        }
    }
}

现在，您可以这样调用enum以获取其值：

Packets.PACKET_SYNC.getValue(); //It will return 1

---

在Java中，如果您正在寻找值，则可以将值分配给Enum。它将如下所示：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3);

    private int value;

    Packets(int value){
        this.value = value;
    }

    public int getValue(){
        return value;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(14),
    PACKET_FILLI(15),
    PACKET_GLASSI(16);

    private final int id;

    private MyEnum(final int id) {
        this.id = id;
    }

    public final int getId() {
        return index;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets(){
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id){
        this.id = id;
    }

    public static void initIds(){
        for(Packets p : Packets.values()){
            if(p.getId()==-1){
                if(p.ordinal()==0){
                    p.setId(0);
                }else{
                    p.setId(Packets.values()[p.ordinal()-1].getId()+1);
                }
            }
        }
    }
}

现在，您可以这样调用enum以获取其值：

Packets.PACKET_SYNC.getValue(); //It will return 1

---

您可以向枚举中添加一个字段，在枚举常量的构造函数调用中初始化该字段，然后从公共getter返回该字段。这应该是这样的：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3);

    private int value;

    Packets(int value){
        this.value = value;
    }

    public int getValue(){
        return value;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(14),
    PACKET_FILLI(15),
    PACKET_GLASSI(16);

    private final int id;

    private MyEnum(final int id) {
        this.id = id;
    }

    public final int getId() {
        return index;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets(){
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id){
        this.id = id;
    }

    public static void initIds(){
        for(Packets p : Packets.values()){
            if(p.getId()==-1){
                if(p.ordinal()==0){
                    p.setId(0);
                }else{
                    p.setId(Packets.values()[p.ordinal()-1].getId()+1);
                }
            }
        }
    }
}

---

您可以向枚举中添加一个字段，在枚举常量的构造函数调用中初始化该字段，然后从公共getter返回该字段。这应该是这样的：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3);

    private int value;

    Packets(int value){
        this.value = value;
    }

    public int getValue(){
        return value;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(14),
    PACKET_FILLI(15),
    PACKET_GLASSI(16);

    private final int id;

    private MyEnum(final int id) {
        this.id = id;
    }

    public final int getId() {
        return index;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets(){
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id){
        this.id = id;
    }

    public static void initIds(){
        for(Packets p : Packets.values()){
            if(p.getId()==-1){
                if(p.ordinal()==0){
                    p.setId(0);
                }else{
                    p.setId(Packets.values()[p.ordinal()-1].getId()+1);
                }
            }
        }
    }
}

---

这不是一个干净的解决方案，但是如果你真的想自动初始化它们以与C++声明相同的方式增加，而不显式地定义每个单独的ID，那么你可以做这样的事情：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3);

    private int value;

    Packets(int value){
        this.value = value;
    }

    public int getValue(){
        return value;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(14),
    PACKET_FILLI(15),
    PACKET_GLASSI(16);

    private final int id;

    private MyEnum(final int id) {
        this.id = id;
    }

    public final int getId() {
        return index;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets(){
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id){
        this.id = id;
    }

    public static void initIds(){
        for(Packets p : Packets.values()){
            if(p.getId()==-1){
                if(p.ordinal()==0){
                    p.setId(0);
                }else{
                    p.setId(Packets.values()[p.ordinal()-1].getId()+1);
                }
            }
        }
    }
}

然后调用initialize，它将为您填写ID：

Packets.initIds();
System.out.println(Packets.PACKET_AVAIL_1.getId()); //3
System.out.println(Packets.PACKET_GLASS.getId()); //13
System.out.println(Packets.PACKET_FILL.getId()); //14
System.out.println(Packets.PACKET_FILLI.getId()); //15

编辑/添加：

如果将代码从

initIds（）

方法移动到静态初始值设定项块中，则不需要在代码中的某个地方调用initialize：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    static {
        for (Packets p : Packets.values()) {
            if (p.getId() == -1) {
                if (p.ordinal() == 0) {
                    p.setId(0);
                } else {
                    p.setId(Packets.values()[p.ordinal() - 1].getId() + 1);
                }
            }
        }
    }

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets() {
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

---

这不是一个干净的解决方案，但是如果你真的想自动初始化它们以与C++声明相同的方式增加，而不显式地定义每个单独的ID，那么你可以做这样的事情：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3);

    private int value;

    Packets(int value){
        this.value = value;
    }

    public int getValue(){
        return value;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(14),
    PACKET_FILLI(15),
    PACKET_GLASSI(16);

    private final int id;

    private MyEnum(final int id) {
        this.id = id;
    }

    public final int getId() {
        return index;
    }
}

public enum Packets
{
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets(){
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id){
        this.id = id;
    }

    public static void initIds(){
        for(Packets p : Packets.values()){
            if(p.getId()==-1){
                if(p.ordinal()==0){
                    p.setId(0);
                }else{
                    p.setId(Packets.values()[p.ordinal()-1].getId()+1);
                }
            }
        }
    }
}

然后调用initialize，它将为您填写ID：

Packets.initIds();
System.out.println(Packets.PACKET_AVAIL_1.getId()); //3
System.out.println(Packets.PACKET_GLASS.getId()); //13
System.out.println(Packets.PACKET_FILL.getId()); //14
System.out.println(Packets.PACKET_FILLI.getId()); //15

编辑/添加：

如果将代码从

initIds（）

方法移动到静态初始值设定项块中，则不需要在代码中的某个地方调用initialize：

public enum Packets {
    PACKET_NONE(0),
    PACKET_SYNC(1),
    PACKET_EXPECT_TO_RECEIVE(2),
    PACKET_AVAIL_1(3),
    PACKET_FILL(13),
    PACKET_GLASS(),
    PACKET_FILLI(),
    PACKET_GLASSI();

    static {
        for (Packets p : Packets.values()) {
            if (p.getId() == -1) {
                if (p.ordinal() == 0) {
                    p.setId(0);
                } else {
                    p.setId(Packets.values()[p.ordinal() - 1].getId() + 1);
                }
            }
        }
    }

    private int id;

    private Packets(int id) {
        this.id = id;
    }

    private Packets() {
        this.id = -1;
    }

    public final int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

---

Java枚举本质上是隐式地定义为其序号（枚举索引）。每个枚举常量本身都是一个新对象，因此，如果要将其指定为

字符串

，那么它只能是

公共静态最终字符串

。您可以根据需要定义任意数量的枚举，无论是否使用枚举。但是，如果这是一个java枚举，那么

Packets.PACKET\u NONE.ordinal（）

将返回0，而

Packets.PACKET\u SYNC.ordinal（）

将返回1，等等。当然，你想通过这样做来实现什么？我只需要一种方法来尽快将枚举映射到整数，而这段代码就是这样做的，但是我在Java中看不到等价的整数是非连续的吗？是的，确实如此，感谢您阐明Java枚举本质上是隐式地定义为它们的序号（枚举索引）。每个枚举常量本身都是一个新对象，因此，如果要将其指定为

字符串

，那么它只能是

公共静态最终字符串

。您可以根据需要定义任意数量的枚举，无论是否使用枚举。但是，如果这是一个java枚举，那么

Packets.PACKET\u NONE.ordinal（）

将返回0，而

Packets.PACKET\u SYNC.ordinal（）

将返回1，等等。当然，你想通过这样做来实现什么？我只需要一种方法来尽快将枚举映射到整数，而这段代码就是这样做的，但是我在Java中看不到任何等价物，整数是非连续的吗？是的，没错，谢谢你对此的解释，因为它模拟了所需的自动增量。虽然这满足了自动增量要求，但代码看起来并不好看。尤其是静态块是在几个构造函数调用之后执行的事实，至少可以说是非直觉的。此外，如果您想知道什么是id数据包，那么自动增量将强制您计算常量，而不是仅在其定义后面读取。请对此投票，因为它模拟了所需的自动增量。虽然这满足自动增量要求，但代码看起来并不好看。尤其是静态块是在几个构造函数调用之后执行的事实，至少可以说是非直觉的。此外，如果您想知道GLASSI的id是什么，那么自动递增将强制您计算常量，而不是仅在其定义后面读取常量。