Konvertieren Sie einen ganzzahligen Wert in eine übereinstimmende Java-Aufzählung

Ich habe eine Aufzählung wie diese:

public enum PcapLinkType {
  DLT_NULL(0)
  DLT_EN10MB(1)
  DLT_EN3MB(2),
  DLT_AX25(3),
  /*snip, 200 more enums, not always consecutive.*/
  DLT_UNKNOWN(-1);
    private final int value;   

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

Jetzt bekomme ich ein Int von der externen Eingabe und möchte die passende Eingabe - eine Ausnahme auszulösen, wenn ein Wert nicht existiert, ist in Ordnung, aber vorzugsweise hätte ich es DLT_UNKNOWN in diesem Fall.

int val = in.readInt();
PcapLinkType type = ???; /*convert val to a PcapLinkType */

Sie müssten dies manuell tun, indem Sie der Klasse eine statische Zuordnung hinzufügen, die Ganzzahlen Aufzählungen zuordnet, z

private static final Map<Integer, PcapLinkType> intToTypeMap = new HashMap<Integer, PcapLinkType>();
static {
    for (PcapLinkType type : PcapLinkType.values()) {
        intToTypeMap.put(type.value, type);
    }
}

public static PcapLinkType fromInt(int i) {
    PcapLinkType type = intToTypeMap.get(Integer.valueOf(i));
    if (type == null) 
        return PcapLinkType.DLT_UNKNOWN;
    return type;
}

Es gibt eine statische Methode , values()die ist dokumentiert, aber nicht , wo man es erwarten würde: http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

enum MyEnum {
    FIRST, SECOND, THIRD;
    private static MyEnum[] allValues = values();
    public static MyEnum fromOrdinal(int n) {return allValues[n];}
}

Im Prinzip können Sie nur verwenden values()[i], aber es gibt Gerüchte, dass values()bei jedem Aufruf eine Kopie des Arrays erstellt wird.

Sie müssen eine neue statische Methode erstellen, bei der Sie PcapLinkType.values ​​() iterieren und vergleichen:

public static PcapLinkType forCode(int code) {
    for (PcapLinkType typе : PcapLinkType.values()) {
        if (type.getValue() == code) {
            return type;
        }
    }
    return null;
 }

Das wäre in Ordnung, wenn es selten genannt wird. Wenn es häufig aufgerufen wird, sehen Sie sich die Mapvon anderen vorgeschlagene Optimierung an.

Sie können so etwas tun, um sie alle automatisch in einer Sammlung zu registrieren, mit der Sie dann die Ganzzahlen einfach in die entsprechende Aufzählung konvertieren können. (Übrigens ist es nicht erlaubt , sie der Karte im Enum-Konstruktor hinzuzufügen . Es ist schön, auch nach vielen Jahren mit Java neue Dinge zu lernen. :)

public enum PcapLinkType {
    DLT_NULL(0),
    DLT_EN10MB(1),
    DLT_EN3MB(2),
    DLT_AX25(3),
    /*snip, 200 more enums, not always consecutive.*/
    DLT_UNKNOWN(-1);

    private static final Map<Integer, PcapLinkType> typesByValue = new HashMap<Integer, PcapLinkType>();

    static {
        for (PcapLinkType type : PcapLinkType.values()) {
            typesByValue.put(type.value, type);
        }
    }

    private final int value;

    private PcapLinkType(int value) {
        this.value = value;
    }

    public static PcapLinkType forValue(int value) {
        return typesByValue.get(value);
    }
}

wenn du so eine Aufzählung hast

public enum PcapLinkType {
  DLT_NULL(0)
  DLT_EN10MB(1)
  DLT_EN3MB(2),
  DLT_AX25(3),
  DLT_UNKNOWN(-1);

    private final int value;   

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

dann kannst du es gerne benutzen

PcapLinkType type = PcapLinkType.values()[1]; /*convert val to a PcapLinkType */

Wie @MeBigFatGuy sagt, außer dass Sie Ihren static {...}Block dazu bringen können, eine Schleife über die values()Sammlung zu verwenden:

static {
    for (PcapLinkType type : PcapLinkType.values()) {
        intToTypeMap.put(type.getValue(), type);
    }
}

Ich weiß, dass diese Frage ein paar Jahre alt ist, aber da Java 8 uns inzwischen gebracht hat Optional, dachte ich, ich würde eine Lösung anbieten, die es (und Streamund Collectors) verwendet:

public enum PcapLinkType {
  DLT_NULL(0),
  DLT_EN3MB(2),
  DLT_AX25(3),
  /*snip, 200 more enums, not always consecutive.*/
  // DLT_UNKNOWN(-1); // <--- NO LONGER NEEDED

  private final int value;
  private PcapLinkType(int value) { this.value = value; }

  private static final Map<Integer, PcapLinkType> map;
  static {
    map = Arrays.stream(values())
        .collect(Collectors.toMap(e -> e.value, e -> e));
  }

  public static Optional<PcapLinkType> fromInt(int value) {
    return Optional.ofNullable(map.get(value));
  }
}

Optionalist wie null: Es stellt einen Fall dar, in dem es keinen (gültigen) Wert gibt. Es ist jedoch eine typsichere Alternative zu nulloder ein Standardwert, z. B. DLT_UNKNOWNweil Sie vergessen könnten, nach nulloder zu DLT_UNKNOWNsuchen. Sie sind beide gültige PcapLinkTypeWerte! Im Gegensatz dazu können Sie Optional<PcapLinkType>einer Variablen vom Typ keinen Wert zuweisen PcapLinkType. OptionalLässt Sie zuerst nach einem gültigen Wert suchen.

Wenn Sie aus DLT_UNKNOWNGründen der Abwärtskompatibilität oder aus einem anderen Grund beibehalten möchten, können Sie dies natürlich Optionalauch in diesem Fall verwenden, indem Sie orElse()es als Standardwert angeben:

public enum PcapLinkType {
  DLT_NULL(0),
  DLT_EN3MB(2),
  DLT_AX25(3),
  /*snip, 200 more enums, not always consecutive.*/
  DLT_UNKNOWN(-1);

  private final int value;
  private PcapLinkType(int value) { this.value = value; }

  private static final Map<Integer, PcapLinkType> map;
  static {
    map = Arrays.stream(values())
        .collect(Collectors.toMap(e -> e.value, e -> e));
  }

  public static PcapLinkType fromInt(int value) {
    return Optional.ofNullable(map.get(value)).orElse(DLT_UNKNOWN);
  }
}

Sie können Ihrer Aufzählung eine statische Methode hinzufügen, die a intals Parameter akzeptiert und a zurückgibt PcapLinkType.

public static PcapLinkType of(int linkType) {

    switch (linkType) {
        case -1: return DLT_UNKNOWN
        case 0: return DLT_NULL;

        //ETC....

        default: return null;

    }
}

Das benutze ich:

public enum Quality {ENOUGH,BETTER,BEST;
                     private static final int amount = EnumSet.allOf(Quality.class).size();
                     private static Quality[] val = new Quality[amount];
                     static{ for(Quality q:EnumSet.allOf(Quality.class)){ val[q.ordinal()]=q; } }
                     public static Quality fromInt(int i) { return val[i]; }
                     public Quality next() { return fromInt((ordinal()+1)%amount); }
                    }

static final PcapLinkType[] values  = { DLT_NULL, DLT_EN10MB, DLT_EN3MB, null ...}    

...

public static PcapLinkType  getPcapLinkTypeForInt(int num){    
    try{    
       return values[int];    
    }catch(ArrayIndexOutOfBoundsException e){    
       return DLT_UKNOWN;    
    }    
}    

Es gibt keine Möglichkeit, ganzzahlige Aufzählungstypen elegant zu behandeln. Möglicherweise möchten Sie anstelle Ihrer Lösung eine auf Zeichenfolgen basierende Aufzählung verwenden. Nicht immer ein bevorzugter Weg, aber er existiert immer noch.

public enum Port {
  /**
   * The default port for the push server.
   */
  DEFAULT("443"),

  /**
   * The alternative port that can be used to bypass firewall checks
   * made to the default <i>HTTPS</i> port.
   */
  ALTERNATIVE("2197");

  private final String portString;

  Port(final String portString) {
    this.portString = portString;
  }

  /**
   * Returns the port for given {@link Port} enumeration value.
   * @return The port of the push server host.
   */
  public Integer toInteger() {
    return Integer.parseInt(portString);
  }
}