Obtenir enum associé à la valeur int

Auparavant, j'avais mes énumérations LegNo définies simplement comme:

NO_LEG, LEG_ONE, LEG_TWO

et en appelant return LegNo.values()[i];, j'ai pu obtenir la valeur associée à chaque enum.

Mais maintenant, j'ai décidé que je veux que l' LegNoénumération NO_LEGsoit le int -1 au lieu de 0, alors j'ai décidé d'utiliser un constructeur privé pour initialiser et définir sa valeur int

NO_LEG(-1), LEG_ONE(1), LEG_TWO(2);

private LegNo(final int leg) { legNo = leg; }

la seule chose maintenant est que parce que je le fais de cette façon, la values()méthode ne fonctionnera pas pour l' NO_LEGénumération. Comment puis-je obtenir l'énumération associée à l'int? Existe-t-il un moyen efficace de faire cela autre que d'utiliser une instruction case switch ou un if-elseif-elseif

Je peux voir beaucoup de questions SO liées à l'obtention de la valeur int à partir de l'énumération, mais je suis après l'inverse.

EDIT août 2018

Aujourd'hui, je mettrais en œuvre cela comme suit

public enum LegNo {
    NO_LEG(-1), LEG_ONE(1), LEG_TWO(2);

    private final int value;

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

    public static Optional<LegNo> valueOf(int value) {
        return Arrays.stream(values())
            .filter(legNo -> legNo.value == value)
            .findFirst();
    }
}

Vous devrez maintenir un mappage à l'intérieur de l'énumération.

public enum LegNo {
    NO_LEG(-1), LEG_ONE(1), LEG_TWO(2);

    private int legNo;

    private static Map<Integer, LegNo> map = new HashMap<Integer, LegNo>();

    static {
        for (LegNo legEnum : LegNo.values()) {
            map.put(legEnum.legNo, legEnum);
        }
    }

    private LegNo(final int leg) { legNo = leg; }

    public static LegNo valueOf(int legNo) {
        return map.get(legNo);
    }
}

Le bloc statique ne sera appelé qu'une seule fois, il n'y a donc pratiquement aucun problème de performances ici.

EDIT: renommé la méthode en valueOfcar elle est plus en ligne avec d'autres classes Java.

Vous pouvez également inclure une méthode statique dans l'énumération qui itère sur tous les membres et renvoie la méthode correcte.

public enum LegNo {
   NO_LEG(-1),
   LEG_ONE(1),
   LEG_TWO(2);

   private int legIndex;

   private LegNo(int legIndex) { this.legIndex = legIndex; }

   public static LegNo getLeg(int legIndex) {
      for (LegNo l : LegNo.values()) {
          if (l.legIndex == legIndex) return l;
      }
      throw new IllegalArgumentException("Leg not found. Amputated?");
   }
}

Maintenant, si vous voulez obtenir une valeur Enum par l'entier, il vous suffit d'utiliser:

int myLegIndex = 1; //expected : LEG_ONE
LegNo myLeg = LegNo.getLeg(myLegIndex);

La réponse d'adarshr adaptée à Java 8:

import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toMap;

import java.util.Map;

public enum LegNo {
    NO_LEG(-1), LEG_ONE(1), LEG_TWO(2);

    private final int legNo;

    private final static Map<Integer, LegNo> map =
            stream(LegNo.values()).collect(toMap(leg -> leg.legNo, leg -> leg));

    private LegNo(final int leg) {
        legNo = leg;
    }

    public static LegNo valueOf(int legNo) {
        return map.get(legNo);
    }
}

Vous pouvez également accéder à la valeur Enum correspondant à une valeur entière donnée simplement en appelant la méthode values ​​() sur enum LegNo. Il renvoie le champ d'énumérations LegNo: LegNo.values()[0]; //returns LEG_NO LegNo.values()[1]; //returns LEG_ONE LegNo.values()[2]; //returns LEG_TWO

Pas exactement ce qu'il cherchait, mais assez proche et très simple en effet. (Bien que le sujet soit mort, il pourrait être utile pour quelqu'un d'autre.)

Java 8 façon avec valeur par défaut:

public enum LegNo {
    NO_LEG(-1), LEG_ONE(1), LEG_TWO(2);

    private final int legNo;

    LegNo(int legNo) {
        this.legNo = legNo;
    }

    public static LegNo find(int legNo, Supplier<? extends LegNo> byDef) {
        return Arrays.asList(LegNo.values()).stream()
                .filter(e -> e.legNo == legNo).findFirst().orElseGet(byDef);
    }
}

appeler:

LegNo res = LegNo.find(0, () -> LegNo.NO_LEG);

ou avec exception:

LegNo res = LegNo.find(0, () -> {
    throw new RuntimeException("No found");
});

Étant donné que votre énumération ne contient que 3 éléments, le moyen le plus rapide sera d'utiliser simplement une série de if else, comme vous l'avez suggéré.

edit: la réponse fournie par adarshr est mieux adaptée aux cas généraux, où il existe de nombreuses valeurs d'énumération, mais je pense que c'est exagéré pour votre problème.

public enum LegNo {
    NO_LEG(-1), LEG_ONE(1), LEG_TWO(2);

    private int legNo;

    private LegNo(int leg) { legNo = leg; }

    public static LegNo valueOf(int legNo) {
        for (LegNo leg : LegNo.values()) {
            if (leg.legNo == legNo) return leg;
        }   
    }
}

assert LegNo.valueOf(2) == LegNo.LEG_TWO
assert LegNo.valueOf(3) == null

public enum LegNo {

  NO_LEG(-1), LEG_ONE(1), LEG_TWO(2);

  private final int code;

  LegNo(int code) {
    this.code = code;
    ReverseStorage.reverseMap.put(code, this);
  }

  public static Optional<LegNo> getByCode(int code) {
    return Optional.ofNullable(ReverseStorage.reverseMap.get(code));
  }

  private static final class ReverseStorage {
    private static final Map<Integer, LegNo> reverseMap = new LinkedHashMap<>();
  }
}