Kann ich eine enum-basierend auf dem Wert aus dem Feld?

Referenz, hier ist eine alternative Lösung mit einer HashMap:

enum CrimeCategory {
  ASBO("Anti Social Behaviour"),
  BURG("Burglary"),
  CRIMDAM("Criminal Damage And Arson"),
  DRUGS("Drugs"),
  OTHTHEFT("Other Theft"),
  PUPDISOR("Public Disorder And Weapons"),
  ROBBERY("Robbery"),
  SHOPLIF("Shoplifting"),
  VEHICLE("Vehicle Crime"),
  VIOLENT("Violent Crime"),
  OTHER("Other Crime");

  private static final Map<String, CrimeCategory> map = new HashMap<>(values().length, 1);

  static {
    for (CrimeCategory c : values()) map.put(c.category, c);
  }

  private final String category;

  private CrimeCategory(String category) {
    this.category = category;
  }

  public static CrimeCategory of(String name) {
    CrimeCategory result = map.get(name);
    if (result == null) {
      throw new IllegalArgumentException("Invalid category name: " + name);
    }
    return result;
  }
}

Statische factory-Methoden, die eine enum-Konstanten, basierend auf dem Wert einer Instanz-Feld in einer der beiden Formen, beschrieben in den anderen Antworten: die Lösung basiert auf der Iteration der enum-Werte oder eine Lösung basierend auf einem HashMap.

Für Enumerationen, die mit einer kleinen Anzahl von Konstanten, die iterative Lösung sollte so performant wie die HashMap Lösung (die erfordert die Berechnung der hash-code ist, passt es in einen Eimer, und vorausgesetzt, es werden keine hash-Kollisionen).

Für größere enums, die map-basierten Lösung werden immer leistungsstärker (aber erfordert Speicherplatz im Speicher). Allerdings, wenn die factory-Methode aufgerufen wird, wird selten dann die Allgemeine Verbesserung der performance mit einer Karte könnte noch unendlich klein.

Die Allgemeine Entscheidung für eine iterative lookup-oder eine map-basierten Suche für die statische factory-Methode wird hängt letztendlich von deinen Anforderungen und der Umgebung. Es ist nie falsch, mit zu beginnen eine iterative lookup-und dann ändern, um eine map-basierte Implementierung, wenn die Profilerstellung zeigt eine aktuelle performance-problem.

Schließlich, seit Java 8, die Streams API ermöglicht eine pipeline-basierte Lösung für die Kartierung (das sollte die Leistung ähnlich der iterativen Lösung). Zum Beispiel, sagen, dass Sie möchten, erstellen Sie eine Schnittstelle, die Sie verwenden, auf jede enum-Klasse, drücken Sie Ihre Absicht, dass es sein sollte matchable durch eine eigene Instanz-Felder. Nennen wir diese Schnittstelle Matchable. Dieses interface definiert eine Methode gibt die Instanz-Feld, welches Sie anpassen möchten (zB. getField()). Diese Schnittstelle kann auch definieren Sie eine statische factory-Methode zum zurückgeben einer Konstante von jeder Implementierung von enum-Klasse:

interface Matchable {

    Object getField();

    public static <E extends Enum<E> & Matchable> E forToken(Class<E> cls, Object token) {

        return Stream.of(cls.getEnumConstants())
            .filter(e -> e.getField().equals(token))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("Unknown token '" +
                    token + "' for enum " + cls.getName()));
    }
}

Nun, jeder enum-Klasse, die Sie definieren, die Matchable können die Matchable.forToken() statische factory-Methode, um die enum-Konstanten, deren Instanz-Feld dem Wert entspricht, den angegebenen parameter.

Den generischen Typ-Deklaration E extends Enum<E> & Matchable versichert, dass die type-token übergeben werden der Methode als parameter werden für eine enum-Klasse, die Matchable (sonst wird der code nicht kompiliert).