Converti il ​​valore intero nella corrispondenza di Java Enum

Ho un'enumerazione come questa:

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

Ora ottengo un int dall'input esterno e voglio l'input corrispondente: lanciare un'eccezione se un valore non esiste è ok, ma preferibilmente lo farei DLT_UNKNOWN in quel caso.

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

Dovresti farlo manualmente, aggiungendo una mappa statica nella classe che mappa Integer su enumerazioni, come

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

C'è un metodo statico values()che è documentato, ma non dove ti aspetteresti: 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];}
}

In linea di principio, puoi usare solo values()[i], ma ci sono voci che values()creeranno una copia dell'array ogni volta che viene invocato.

Dovrai creare un nuovo metodo statico in cui iterare PcapLinkType.values ​​() e confrontare:

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

Andrebbe bene se viene chiamato raramente. Se viene chiamato frequentemente, guarda l' Mapottimizzazione suggerita da altri.

Puoi fare qualcosa del genere per registrarli automaticamente tutti in una raccolta con la quale convertire facilmente gli interi nell'enumerazione corrispondente. (A proposito, non è consentito aggiungerli alla mappa nel costruttore enum . È bello imparare cose nuove anche dopo molti anni di utilizzo di 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);
    }
}

se hai enum come questo

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

allora puoi usarlo come

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

Come dice @MeBigFatGuy, tranne per il fatto che puoi fare in modo che il tuo static {...}blocco utilizzi un loop sulla values()raccolta:

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

So che questa domanda è vecchia di alcuni anni, ma poiché Java 8, nel frattempo, ci ha portato Optional, ho pensato di offrire una soluzione utilizzandolo (e Streame 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));
  }
}

Optionalè come null: rappresenta un caso in cui non c'è un valore (valido). Ma è un'alternativa più indipendente dai tipi nullo un valore predefinito, ad esempio DLT_UNKNOWNperché potresti dimenticare di controllare i casi nullo DLT_UNKNOWN. Sono entrambi PcapLinkTypevalori validi ! Al contrario, non è possibile assegnare un Optional<PcapLinkType>valore a una variabile di tipo PcapLinkType. Optionalti fa verificare prima un valore valido.

Ovviamente, se vuoi conservare DLT_UNKNOWNper compatibilità con le versioni precedenti o qualsiasi altra ragione, puoi comunque usare Optionalanche in quel caso, usando orElse()per specificarlo come valore predefinito:

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

È possibile aggiungere un metodo statico nella propria enumerazione che accetta un intcome parametro e restituisce un file PcapLinkType.

public static PcapLinkType of(int linkType) {

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

        //ETC....

        default: return null;

    }
}

Questo è quello che 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;    
    }    
}    

Non è possibile gestire in modo elegante i tipi enumerati basati su numeri interi. Potresti pensare di utilizzare un'enumerazione basata su stringhe invece della tua soluzione. Non è sempre un modo preferito, ma esiste ancora.

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