Groß-/Kleinschreibungsunabhängiger Abgleich einer Zeichenfolge mit einer Java-Enumeration

Java bietet ein valueOf() Methode für alle Enum<T> Objekt, also gegeben an enum wie

public enum Day {
  Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
}

man kann nachschlagen wie

Day day = Day.valueOf("Monday");

Wenn die Zeichenfolge übergeben wird valueOf() stimmt nicht mit einem vorhandenen überein (Groß-/Kleinschreibung beachten). Day Wert, ein IllegalArgumentException ist geworfen.

Um einen Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung durchzuführen, kann man eine benutzerdefinierte Methode in die schreiben Day Aufzählung, zB

public static Day lookup(String day) {
  for (Day d : Day.values()) {
    if (d.name().equalsIgnoreCase(day)) {
      return type;
    }
  }
  return null;
}

Gibt es eine generische Möglichkeit, ohne das Zwischenspeichern von Werten oder anderen zusätzlichen Objekten zu verwenden, um eine Statik zu schreiben lookup() Methode wie oben nur einmal (also nicht für jeden enum), da die values() -Methode wird implizit zu hinzugefügt Enum<E> Klasse zur Kompilierzeit?

Die Signatur eines solchen “Generikums” lookup() Methode wäre ähnlich wie die Enum.valueOf() Methode, dh:

public static <T extends Enum<T>> T lookup(Class<T> enumType, String name);

und es würde genau die Funktionalität der implementieren Day.lookup() Methode für alle enumohne die gleiche Methode für jede neu schreiben zu müssen enum.

Ich fand es etwas schwierig, die spezielle Mischung von Generika zu bekommen, aber das funktioniert.

public static <T extends Enum<?>> T searchEnum(Class<T> enumeration,
        String search) {
    for (T each : enumeration.getEnumConstants()) {
        if (each.name().compareToIgnoreCase(search) == 0) {
            return each;
        }
    }
    return null;
}

Beispiel

public enum Horse {
    THREE_LEG_JOE, GLUE_FACTORY
};

public static void main(String[] args) {
    System.out.println(searchEnum(Horse.class, "Three_Leg_Joe"));
    System.out.println(searchEnum(Day.class, "ThUrSdAy"));
}

Ich denke, der einfachste sichere Weg, dies zu tun, wäre:

Arrays.stream(Day.values())
    .filter(e -> e.name().equalsIgnoreCase(dayName)).findAny().orElse(null);

Oder wenn Sie das Klassenobjekt verwenden möchten, dann:

Arrays.stream(enumClass.getEnumConstants())
    .filter(e -> (Enum)e.name().equalsIgnoreCase(dayName)).findAny().orElse(null);

Ab Version 3.8 Apache Commons-Sprache EnumUtils hat zwei praktische Methoden dafür:

• getEnumIgnoreCase(final Class<E> enumClass, final String enumName)
• isValidEnumIgnoreCase(final Class<E> enumClass, final String enumName)

Eine generische Lösung wäre, sich an die Konvention zu halten Konstanten werden in Großbuchstaben geschrieben. (Oder verwenden Sie in Ihrem speziellen Fall einen Großbuchstaben für die Suchzeichenfolge).

public static <E extends Enum<E>> E lookup(Class<E> enumClass,
        String value) {
    String canonicalValue.toUpperCase().replace(' ', '_');
    return Enum<E>.valueOf(enumClass, canonicalValue);
}

enum Day(MONDAY, ...);
Day d = lookup(Day,class, "thursday");

Für Android und relativ kurze Enums mache ich die einfache Schleife und vergleiche den Namen, wobei ich die Groß- und Kleinschreibung ignoriere.

public enum TransactionStatuses {
    public static TransactionStatuses from(String name) {
        for (TransactionStatuses status : TransactionStatuses.values()) {
            if (status.name().equalsIgnoreCase(name)) {
                return status;
            }
        }
        return null;
    }
}

Sie können verwenden Class‘s getEnumConstants() Methodedie ein Array aller Aufzählungstypen zurückgibt, wenn die Class stellt eine Aufzählung dar, oder null wenn nicht.

Gibt die Elemente dieser Aufzählungsklasse zurück oder null, wenn dieses Klassenobjekt keinen Aufzählungstyp darstellt.

Ihre erweiterte for-Schleife würde wie folgt aussehen:

for (T d : enumType.getEnumConstants()) {

Ich kann das glauben, oder eine ähnliche Lösung wurde noch nicht gepostet. Meine bevorzugte Anlaufstelle hier (es besteht absolut keine Notwendigkeit für ein ‘Nachschlagen’, nur ein klügeres valueOf. Außerdem sind Enum-Werte als Bonus alle in Großbuchstaben, wie wir ehemaligen C++-Anwender denken, dass sie es sein sollten …

public enum Day {
    MONDAY("Monday"), 
    TUESDAY("Tuesday"), 
    WEDNESDAY("Wednesday"),
    THURSDAY("Thursday"), 
    FRIDAY("Friday"),
    SATURDAY("Saturday"),
    SUNDAY("Sunday"); 

    public static Day valueOfIgnoreCase(String name) {
         return valueOf(name.toUpperCase());
    }

    private final String displayName; 

    Day(String displayName) {
        this.displayName = displayName;
    }

    @Override
    public String toString() {
        return this.displayName; 
    }
}

Und dann:

Day day = Day.valueOfIgnoreCase("mOnDay"); 
System.out.println(day); 

>>> Monday