Groß- / Kleinschreibung bei der Übereinstimmung einer Zeichenfolge mit einer Java-Enumeration

Java bietet eine valueOf() Methode für jeden Enum<T> Objekt, um so eine enum wie

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

kann man eine lookup wie

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

Wenn die Zeichenfolge übergeben, um valueOf() nicht übereinstimmt (case sensitive) ein bestehendes Day Wert, ein IllegalArgumentException geworfen wird.

Dazu eine case-insensitive matching, die man schreiben kann eine benutzerdefinierte Methode innerhalb der Day enum, z.B.

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

Gibt es eine generische Art und Weise, ohne die Verwendung von Zwischenspeicherung der Werte oder andere zusätzliche Objekte, zu schreiben, eine statische lookup() Methode wie oben, nur einmal (D. H., nicht für jede enum), gegeben, dass die values() Methode wird implizit Hinzugefügt, um die Enum<E> Klasse zur compile-Zeit?

Die Signatur von einem solchen "generischen" lookup() Methode wäre ähnlich der Enum.valueOf() - Methode, D. H.:

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

und es würde implementieren, die genau die Funktionalität des Day.lookup() - Methode für alle enum, ohne die Notwendigkeit zu re-schreiben die gleiche Methode, die für jeden enum.

Kommentar zu dem Problem - Öffnen

Ich bin sicher, dass Sie es wissen, aber der Grund, warum das Problem überhaupt erschienen ist, dass Sie don ' T-stick auf die Java-enum-Namenskonvention. Wenn Sie wurden mit standard-Großbuchstaben benennen, würden Sie benutzen Sie einfach - Tag.valueOf(day.toUpperCase()) in Ihrem lookup-Methode Kommentarautor: kiedysktos

Nein, die gleiche Anforderung gilt unabhängig davon, Fall oder anderen Namenskonventionen. Eine gemeinsame Methode für alle Zwecke, war die Anforderung. 🙂 Kommentarautor: PNS

InformationsquelleAutor der Frage PNS | 2015-02-04

Fand ich immer die Besondere Mischung von Generika ein wenig tricky, aber so funktioniert es.

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

InformationsquelleAutor der Antwort Adam

Ich würde denken, der sicher einfachste Weg, es zu tun wäre:

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

Oder wenn Sie möchten, verwenden Sie das class-Objekt, dann:

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

InformationsquelleAutor der Antwort sprinter

4

Können Sie Class's getEnumConstants() Methode, das gibt ein array mit allen enum-Typen, wenn die Class stellt ein enum, oder null wenn nicht.

Gibt die Elemente des enum-Klasse oder null, wenn das Class-Objekt repräsentiert nicht eine enum-Typ.

Ihrer erweiterten for-Schleife Zeile würde wie folgt Aussehen:
```
for (T d : enumType.getEnumConstants()) {
```
InformationsquelleAutor der Antwort rgettman

Eine generische Lösung wäre keeo der Konvention, dass Konstanten werden in Großbuchstaben. (Oder in Ihrem speziellen Fall mit einem Kapital auf die look-up-string).

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

InformationsquelleAutor der Antwort Joop Eggen

Für Android und relativ kurz Enums, ich mache die einfache Schleife und vergleichen Sie den Namen ignorieren der Fall.

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

InformationsquelleAutor der Antwort Alen Siljak

und es würde implementieren, die genau die Funktionalität von Tag zu Tag.lookup()
Methode für jede enum, ohne die Notwendigkeit zu re-schreiben die gleiche Methode, die für
jedes enum.

Wahrscheinlich schreiben Sie eine utility-Klasse für das tun, als die folgenden.

public class EnumUtil {

    private EnumUtil(){
        //A utility class
    }

    public static <T extends Enum<?>> T lookup(Class<T> enumType,
                                                   String name) {
        for (T enumn : enumType.getEnumConstants()) {
            if (enumn.name().equalsIgnoreCase(name)) {
                return enumn;
            }
        }
        return null;
    }

    //Just for testing
    public static void main(String[] args) {
        System.out.println(EnumUtil.lookup(Day.class, "friday"));
        System.out.println(EnumUtil.lookup(Day.class, "FrIdAy"));
    }

}

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

Wäre es schön gewesen, wenn es eine Möglichkeit in Java, die für uns zu einer Verlängerung der Enum-Klasse implizit durch das hinzufügen von Methoden nur die Art und Weise Werte () - Methode Hinzugefügt, aber ich glaube nicht, dass es einen Weg gibt, das zu tun.

InformationsquelleAutor der Antwort Nandana

1

Ab version 3.8 apache-commons-lang EnumUtils hat zwei praktische Methoden:
- getEnumIgnoreCase(final Class<E> enumClass, final String enumName)
- isValidEnumIgnoreCase(final Class<E> enumClass, final String enumName)
InformationsquelleAutor der Antwort Enigo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.