Getting Enum from an integer having a Class object

Question

I have seen this which is pretty nice solution if i had a string instead of integer, but in case all i have is the specific enum's class object and an integer, how to do i get the specific enum constant instance?

Answer 1

seem to have found the answer :

((Class<? extends Enum>)clazz).getEnumConstants()[index]

although for any-one looking for that, you should consider following @Daniel Pryden answer as most likely that using this in most use cases i can think of is bad practice.

Answer 2

Relying on the ordinal value of Java enum constants is poor practice -- it's too easy to accidentally reorder them, which would then break your code. The better solution is to simply provide your own integer that you can use instead:

public enum MyThing {
  FOO(1),
  BAR(2),
  BAZ(3);

  private final int thingId;

  private MyThing(int thingId) {
    this.thingId = thingId;
  }

  public int getThingId() {
    return thingId;
  }
}

Then whenever you want to get the thingId from a MyThing, just call the getThingId() method:

void doSomething(MyThing thing) {
  System.out.printf("Got MyThing object %s with ID %d\n",
    thing.name(), thing.getThingId());
}

If you want to be able to look up a MyThing by its thingId, you can build a lookup table yourself and store it in a static final field:

  private static final Map<Integer, MyThing> LOOKUP
      = createLookupMap();

  private static Map<Integer, MyThing> createLookupMap() {
    Map<Integer, MyThing> lookupMap = new HashMap<>();
    for (MyThing thing : MyThing.values()) {
      lookupMap.put(thing.getThingId(), thing);
    }
    return Collections.unmodifiableMap(lookupMap);
  }

  public static MyThing getThingById(int thingId) {
    MyThing result = LOOKUP.get(thingId);
    if (result == null) {
      throw new IllegalArgumentException(
        "This is not a valid thingId: " + thingId);
    }
    return result;
  }

If you end up having a lot of enum classes and you want to do a similar thing with each of them, you can define an interface for that:

public interface Identifiable {
  int getId();
}

And then make your enum implement that interface:

public enum MyThing implements Identifiable {
  ...

  @Override
  public int getId() {
    return thingId;
  }
}

And then you could build a reusable mechanism for looking up an Identifiable object based on its ID.