Лучшая практика обратного просмотра Java enum

Maps.uniqueIndex из Guava от Google весьма удобен для построения поисковых карт.

Обновление: вот пример использования Maps.uniqueIndex с Java 8:

public enum MyEnum {
    A(0), B(1), C(2);

    private static final Map<Integer, MyEnum> LOOKUP = Maps.uniqueIndex(
                Arrays.asList(MyEnum.values()),
                MyEnum::getStatus
    );    

    private final int status;

    MyEnum(int status) {
        this.status = status;
    }

    public int getStatus() {
        return status;
    }

    @Nullable
    public static MyEnum fromStatus(int status) {
        return LOOKUP.get(status);
    }
}

Хотя статическая карта имеет более высокие накладные расходы, она хороша тем, что предлагает постоянный поиск по code. Время поиска вашей реализации увеличивается линейно с количеством элементов в перечислении. Для небольших перечислений это просто не принесет существенного вклада.

Одна проблема с обеими реализациями (и, возможно, с перечислениями Java в целом) заключается в том, что действительно существует скрытое дополнительное значение, которое Status может принимать: null. В зависимости от правил бизнес-логики, может иметь смысл возвращать фактическое значение перечисления или выдавать Exception, когда поиск «терпит неудачу».

Вот альтернатива, которая может быть даже немного быстрее:

public enum Status {
    WAITING(0),
    READY(1),
    SKIPPED(-1),
    COMPLETED(5);

    private int code;

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

    public int getCode() { return code; }

    public static Status get(int code) {
        switch(code) {
            case  0: return WAITING;
            case  1: return READY;
            case -1: return SKIPPED;
            case  5: return COMPLETED;
        }
        return null;
    }
}

Конечно, это не очень удобно, если вы хотите добавить больше констант позже.

Очевидно, что карта будет обеспечивать постоянный поиск по времени, тогда как цикл - нет. В типичном перечислении с небольшим количеством значений я не вижу проблем с поиском обхода.

Вот альтернатива Java 8 (с модульным тестом):

// DictionarySupport.java :

import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.map.LazyMap;

import java.util.HashMap;
import java.util.Map;

public interface DictionarySupport<T extends Enum<T>> {

    @SuppressWarnings("unchecked")
    Map<Class<?>,  Map<String, Object>> byCodeMap = LazyMap.lazyMap(new HashMap(), (Factory) HashMap::new);

    @SuppressWarnings("unchecked")
    Map<Class<?>,  Map<Object, String>> byEnumMap = LazyMap.lazyMap(new HashMap(), (Factory) HashMap::new);


    default void init(String code) {
        byCodeMap.get(this.getClass()).put(code, this);
        byEnumMap.get(this.getClass()).put(this, code) ;
    }

    static <T extends Enum<T>> T getByCode(Class<T> clazz,  String code) {
        clazz.getEnumConstants();
        return (T) byCodeMap.get(clazz).get(code);
    }

    default <T extends Enum<T>> String getCode() {
        return byEnumMap.get(this.getClass()).get(this);
    }
}

// Dictionary 1:
public enum Dictionary1 implements DictionarySupport<Dictionary1> {

    VALUE1("code1"),
    VALUE2("code2");

    private Dictionary1(String code) {
        init(code);
    }
}

// Dictionary 2:
public enum Dictionary2 implements DictionarySupport<Dictionary2> {

    VALUE1("code1"),
    VALUE2("code2");

    private Dictionary2(String code) {
        init(code);
    }
}

// DictionarySupportTest.java:     
import org.testng.annotations.Test;
import static org.fest.assertions.api.Assertions.assertThat;

public class DictionarySupportTest {

    @Test
    public void teetSlownikSupport() {

        assertThat(getByCode(Dictionary1.class, "code1")).isEqualTo(Dictionary1.VALUE1);
        assertThat(Dictionary1.VALUE1.getCode()).isEqualTo("code1");

        assertThat(getByCode(Dictionary1.class, "code2")).isEqualTo(Dictionary1.VALUE2);
        assertThat(Dictionary1.VALUE2.getCode()).isEqualTo("code2");


        assertThat(getByCode(Dictionary2.class, "code1")).isEqualTo(Dictionary2.VALUE1);
        assertThat(Dictionary2.VALUE1.getCode()).isEqualTo("code1");

        assertThat(getByCode(Dictionary2.class, "code2")).isEqualTo(Dictionary2.VALUE2);
        assertThat(Dictionary2.VALUE2.getCode()).isEqualTo("code2");

    }
}

В Java 8 я бы просто добавил в ваше перечисление следующий заводской метод и пропустил карту поиска.

public static Optional<Status> of(int value) {
    return Arrays.stream(values()).filter(v -> value == v.getCode()).findFirst();
}

Оба пути вполне допустимы. И технически у них одинаковое время работы Big-Oh.

Однако, если вы сначала сохраните все значения на карту, вы сэкономите время, необходимое для итерации по набору каждый раз, когда вы хотите выполнить поиск. Итак, я думаю, что статическая карта и инициализатор - немного лучший способ.