web-dev-qa-db-ja.com

Java列挙型逆ルックアップのベストプラクティス

私はそれを見た ブログで提案 以下は、Java enumでgetCode(int)を使用して「逆ルックアップ」を行う合理的な方法だった：

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

    private static final Map<Integer,Status> lookup 
            = new HashMap<Integer,Status>();

    static {
        for(Status s : EnumSet.allOf(Status.class))
            lookup.put(s.getCode(), s);
    }

    private int code;

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

    public int getCode() { return code; }

    public static Status get(int code) { 
        return lookup.get(code); 
    }
}

私にとって、静的マップと静的初期化子はどちらも悪いアイデアのように見えます。最初に考えたのは、ルックアップを次のようにコーディングすることです。

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) { 
        for(Status s : values()) {
            if(s.code == code) return s;
        }
        return null;
    }
}

どちらの方法にも明らかな問題がありますか？また、この種のルックアップを実装する推奨方法はありますか？

javaenumsstatic-initializer
70
Armand

Maps.uniqueIndex Googleの Guava は、ルックアップマップの構築に非常に便利です。

更新：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);
    }
}
24
user638455

静的マップはオーバーヘッドが高くなりますが、codeによる一定時間のルックアップを提供するため、ニースです。実装のルックアップ時間は、列挙内の要素の数に比例して増加します。小さい列挙型の場合、これは単にあまり貢献しません。

両方の実装の1つの問題（そしておそらく、Java列挙一般）の場合）は、Statusが引き継ぐことができる隠された追加の値が本当にあるということです：null。ビジネスロジックのルールによっては、ルックアップが「失敗」したときに、実際の列挙値を返すか、Exceptionをスローするのが理にかなっています。

19
Matt Ball

これはもう少し高速な代替手段です。

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

もちろん、後で定数を追加できるようにしたい場合、これは実際にはメンテナンスできません。

8
Paŭlo Ebermann

明らかに、マップは一定時間のルックアップを提供しますが、ループはそうではありません。値の少ない典型的な列挙型では、トラバーサルルックアップに問題はありません。

5
digitaljoel

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

    }
}
3
Vitaliy Oliynyk

どちらの方法も完全に有効です。そして、彼らは技術的に同じビッグオーの実行時間を持っています。

ただし、すべての値を最初にマップに保存すると、ルックアップを行うたびにセットを反復処理するのにかかる時間を節約できます。そのため、静的マップと初期化子の方が少し良い方法だと思います。

0
jjnguy

このスレッドの他のすべての答えは、静的メソッドを使用しました。別の方法として、インスタンスメソッドを使用した例を提供する必要があると考えました。

public class Main {
    public static void main(String[] args) {
        for (Alphabet item : Alphabet.values()) {
            System.out.println("GET: " + item.getValue() );
            System.out.println("REV: " + item.reverseLookup(item.getValue()) );
        }
    }
}


enum Alphabet {
    X(24) {
        public String reverseLookup(int o) {
            return "X";
        }
    },
    Y(25) {
        public String reverseLookup(int o) {
            return "Y";
        }
    },
    Z(26) {
        public String reverseLookup(int o) {
            return "Z";
        }
    };

    abstract String reverseLookup(int o);

    private final int value;

    Alphabet(final int newValue) {
        value = newValue;
    }

    public int getValue() { return value; }
}
0
djangofan

Java 8では、次のファクトリメソッドを列挙に追加し、ルックアップマップをスキップします。

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