Optimize java enum

Question

My code contain multiple enum like below. Basically that help to use enum via integer instead of enum value. Is it possible apply some sort of optimization like inheritance or something so that all can have behavior like below.

public enum DeliveryMethods {

    STANDARD_DOMESTIC(1), STANDARD_INTERNATIONAL(2), EXPRESS_DOMESTIC(3), EXPRESS_INTERNATIONAL(4);

    private final int code;

    private DeliveryMethods(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    private static final HashMap<Integer, DeliveryMethods> valueMap = new HashMap<>(2);

    static {
        for (DeliveryMethods type : DeliveryMethods.values()) {
            valueMap.put(type.code, type);
        }
    }

    public static DeliveryMethods getValue(int code) {
        return valueMap.get(code);
    }
}

Answer 1

Here is an example showing how you could delegate to another class:

public interface Keyed<K> {
    /**
     * returns the key of the enum
     */
    K getKey();
}

public class KeyEnumMapping<K, E extends Enum<?> & Keyed<K>> {
    private Map<K, E> map = new HashMap<>();

    public KeyEnumMapping(Class<E> clazz) {
        E[] enumConstants = clazz.getEnumConstants();
        for (E e : enumConstants) {
            map.put(e.getKey(), e);
        }
    }

    public E get(K key) {
        return map.get(key);
    }
}

public enum Example implements Keyed<Integer> {
    A(1),
    B(3),
    C(7);

    private static final KeyEnumMapping<Integer, Example> MAPPING = new KeyEnumMapping<>(Example.class);
    private Integer value;

    Example(Integer value) {
        this.value = value;
    }

    @Override
    public Integer getKey() {
        return value;
    }

    public static Example getByValue(Integer value) {
        return MAPPING.get(value);
    }

    public static void main(String[] args) {
        System.out.println(Example.getByValue(3));
    }
}

You could also avoid implementing a Keyed interface and simply pass a Function<E, K> to KeyEnumMapping constructor, that would transform the enum into its key:

public class KeyEnumMapping<K, E extends Enum<?>> {
    private Map<K, E> map = new HashMap<>();

    public KeyEnumMapping(Class<E> clazz, Function<E, K> keyExtractor) {
        E[] enumConstants = clazz.getEnumConstants();
        for (E e : enumConstants) {
            map.put(keyExtractor.apply(e), e);
        }
    }

    public E get(K key) {
        return map.get(key);
    }
}

public enum Example {
    A(1),
    B(3),
    C(7);

    private static final KeyEnumMapping<Integer, Example> MAPPING =
        new KeyEnumMapping<>(Example.class, Example::getValue);
    private Integer value;

    Example(Integer value) {
        this.value = value;
    }

    public Integer getValue() {
        return value;
    }

    public static Example getByValue(Integer value) {
        return MAPPING.get(value);
    }

    public static void main(String[] args) {
        System.out.println(Example.getByValue(3));
    }
}

Answer 2

There is no need for Hashmap unless until it is necessary.It's better to go with switch-case for enum values

I've written to get enum from Integer as well as string

  public enum DeliveryMethods {

    STANDARD_DOMESTIC(1), STANDARD_INTERNATIONAL(2), EXPRESS_DOMESTIC(3), EXPRESS_INTERNATIONAL(4);

    private final int code;

    private DeliveryMethods(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    public static DeliveryMethods fromString(String code) {
        if (code.matches("[1-4]")) {
            return fromInteger(Integer.valueOf(code));
        }
        throw new RuntimeException("No values for code " + code);
    }

    public static DeliveryMethods fromInteger(int code) {
        switch (code) {
            case 1:
                return STANDARD_DOMESTIC;
            case 2:
                return STANDARD_INTERNATIONAL;
            case 3:
                return EXPRESS_DOMESTIC;
            case 4:
                return EXPRESS_INTERNATIONAL;
        }
        throw new RuntimeException("No values for code " + code);
    }

  public static DeliveryMethods fromIntegerType2(int code) {
        for (DeliveryMethods d : DeliveryMethods.values()) {
            if (d.getCode() == code) {
                return d;
            }
        }
        throw new RuntimeException("No values for code " + code);
    }
}

Answer 3

You can consider using the getOrdinal() method of Enum instead of maintaining the 'code' yourself.

http://docs.oracle.com/javase/7/docs/api/java/lang/Enum.html#ordinal()

Even if you maintain the 'code' attribute it is not necessary to maintain the 'valueMap'. Instead you can use the 'values()' method of Enum and iterate over all the enums.