Convierta un valor entero en Java Enum coincidente

Tengo una enumeración como esta:

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;
    }
}

Ahora obtengo un int de la entrada externa y quiero la entrada coincidente: lanzar una excepción si un valor no existe está bien, pero preferiblemente lo haría DLT_UNKNOWN en ese caso.

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

Debería hacer esto manualmente, agregando un mapa estático en la clase que asigna Integers a enumeraciones, como

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;
}

Hay un método estático values()que está documentado, pero no donde lo esperaría: 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];}
}

En principio, puede usar solo values()[i], pero hay rumores que values()crearán una copia de la matriz cada vez que se invoque.

Tendrás que crear un nuevo método estático en el que iterarás PcapLinkType.values ​​() y compararás:

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

Eso estaría bien si se llama raramente. Si se llama con frecuencia, observe la Mapoptimización sugerida por otros.

Puede hacer algo como esto para registrarlos todos automáticamente en una colección con la que luego convertir fácilmente los enteros en la enumeración correspondiente. (Por cierto, no se permite agregarlos al mapa en el constructor de enumeración . Es bueno aprender cosas nuevas incluso después de muchos años de usar Java. :)

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);
    }
}

si tienes una enumeración como esta

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;
    }
}

entonces puedes usarlo como

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

Como dice @MeBigFatGuy, excepto que puede hacer que su static {...}bloque use un bucle sobre la values()colección:

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

Sé que esta pregunta tiene algunos años, pero como Java 8, mientras tanto, nos trajo Optional, pensé en ofrecer una solución usándola (y Streamy Collectors):

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));
  }
}

Optionales como null: representa un caso en el que no hay ningún valor (válido). Pero es una alternativa más segura para los tipos nullo un valor predeterminado, por ejemplo, DLT_UNKNOWNporque podría olvidarse de verificar los casos nullo DLT_UNKNOWN. ¡Ambos son PcapLinkTypevalores válidos ! Por el contrario, no puede asignar un Optional<PcapLinkType>valor a una variable de tipo PcapLinkType.Optionalle hace comprobar primero un valor válido.

Por supuesto, si desea conservar DLT_UNKNOWNpara compatibilidad con versiones anteriores o cualquier otra razón, aún puede usar Optionalincluso en ese caso, usando orElse()para especificarlo como el valor predeterminado:

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);
  }
}

Puede agregar un método estático en su enumeración que acepte un intcomo parámetro y devuelva un PcapLinkType.

public static PcapLinkType of(int linkType) {

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

        //ETC....

        default: return null;

    }
}

Esto es lo que uso:

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;    
    }    
}    

No hay forma de manejar con elegancia los tipos enumerados basados ​​en números enteros. Podría pensar en usar una enumeración basada en cadenas en lugar de su solución. No es una forma preferida todas las veces, pero aún existe.

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);
  }
}