İnt değeriyle ilişkilendirilen numaralandırma

Daha önce, LegNo numaralarım şu şekilde tanımlanmıştı:

NO_LEG, LEG_ONE, LEG_TWO

ve arayarak return LegNo.values()[i]; , her bir enum ile ilişkili değeri elde edebildim.

Ama şimdi LegNonumaralandırmanın NO_LEG0 yerine int -1 olmasını istediğime karar verdim, bu yüzden int değerini başlatmak ve ayarlamak için özel bir kurucu kullanmaya karar verdim

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

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

şu anda tek şey, bu şekilde yaptığım için values()yöntemin NO_LEGenum için işe yaramayacağıdır . İnt ile ilişkili numaralandırmayı nasıl elde ederim? Bunu yapmanın case switch deyimi veya if-elseif-elseif kullanmaktan başka etkili bir yolu var mı?

Numaralandırmadan int değerini almakla ilgili pek çok SO sorusu görebiliyorum, ancak tam tersinin peşindeyim.

DÜZENLEME Ağustos 2018

Bugün bunu şu şekilde uygulayacağım

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

Numaralandırmanın içinde bir eşleme tutmanız gerekecek.

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

Statik blok yalnızca bir kez çağrılacaktır, bu nedenle burada neredeyse hiç performans sorunu yoktur.

DÜZENLEME: Yöntemin valueOfdiğer Java sınıflarıyla daha satır içi olması için yeniden adlandırıldı .

Numaralandırmaya tüm üyeler arasında yinelenen ve doğru olanı döndüren statik bir yöntem de dahil edebilirsiniz.

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

Şimdi, tamsayı ile bir Enum değeri almak istiyorsanız, sadece şunu kullanın:

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

adarshr'ın cevabı Java 8'e uyarlanmıştır:

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

Ayrıca, LegNo numaralandırmasında values ​​() yöntemini çağırarak, verilen tamsayı değerine karşılık gelen Enum değerine de erişebilirsiniz. LegNo numaralandırmalarının alanını döndürür: LegNo.values()[0]; //returns LEG_NO LegNo.values()[1]; //returns LEG_ONE LegNo.values()[2]; //returns LEG_TWO

Tam olarak aradığı şey değil, ama oldukça yakın ve gerçekten de çok basit. (Konu ölmüş olsa da başkası için faydalı olabilir.)

Varsayılan değere sahip Java 8 yolu:

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

aramak:

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

veya İstisna ile:

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

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

Numaranız yalnızca 3 öğe içerdiğinden, en hızlı yol, if elseönerdiğiniz gibi bir dizi kullanmak olacaktır .

düzenleme: adarshr'ın verdiği yanıt, birçok enum değerinin olduğu genel durumlar için daha uygundur, ancak bunun sizin sorununuz için fazla bir şey olduğunu düşünüyorum.

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