Insensible à la casse d'une chaîne à une enum de Java

Java fournit un valueOf() méthode pour chaque Enum<T> objet, donc, étant donné un enum comme

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

on peut faire une recherche comme

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

Si la chaîne passée à valueOf() ne correspond pas (sensible à la casse) un Day valeur, une IllegalArgumentException est levée.

De faire une comparaison insensible à la casse, on peut écrire une méthode personnalisée à l'intérieur de la Day enum, par exemple

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

Est-il de toute façon générique, sans utiliser la mise en cache de valeurs ou autres objets supplémentaires, à écrire une statique lookup() méthode comme ci-dessus qu'une seule fois (c'est à dire, pas pour tous les enum), étant donné que la values() méthode est implicitement ajoutée à la Enum<E> classe au moment de la compilation?

La signature d'un tel "générique" lookup() méthode serait semblable à la Enum.valueOf() méthode, c'est à dire:

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

et qu'il mettrait en œuvre exactement la fonctionnalité de la Day.lookup() méthode pour n'importe quel enum, sans avoir besoin de ré-écrire la même méthode pour chaque enum.

  • Je suis sûr que vous le savez, mais la raison pourquoi le problème est apparu, c'est que vous ne respectez pas les enum de Java convention de nommage. Si vous avez été en utilisant la norme majuscules de nommage, vous utilisez simplement Day.valueOf(day.toUpperCase()) dans votre méthode de recherche
  • Non, la même exigence s'applique quel que soit le cas ou d'autres conventions de nommage. Une méthode commune pour toutes les fins de la demande. 🙂
  • L'ajout de @kiedysktos suggestion (ce qui, pour quelqu'un d'autre lecture, est de loin la solution la plus simple), je soupçonne OP cassé la convention d'affectation de noms parce qu'ils veulent le toString forme d'avoir uniquement la première lettre en majuscule comme c'est grammaticalement correct en anglais. Vous pouvez toujours accomplir ce en surchargeant la méthode toString: return super.toString().substring(0, 1).toUpperCase() + super.toString().substring(1);
InformationsquelleAutor PNS | 2015-02-04
  1. 36

    J'ai trouvé arriver le mélange spécial de génériques est un peu délicat, mais cela fonctionne.

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

    Exemple

    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"));
}
    • Oui, cela fonctionne. Merci pour le pointeur de la getEnumConstants() méthode. J'étais en train d'essayer d'éviter d'appeler le values() méthode par réflexion, qui est ce que la getEnumConstants() en fait, mais apparemment, il n'y a pas de meilleure approche. Par ailleurs, vous pouvez simplement utiliser equalsIgnoreCase() pour la comparaison de chaînes de caractères.
    • Serait-il intéressant de mettre en cache les valeurs dans une carte une fois, plutôt que de l'itération à chaque fois? par exemple, Map<String, MyEnum> où la valeur est déjà mis en minuscule ou quelque chose.
    InformationsquelleAutor Adam
  2. 27

    Je pense que le plus simple moyen sûr de le faire serait:

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

    Ou si vous souhaitez utiliser la classe de l'objet, puis:

    Arrays.stream(enumClass.getEnumConstants())
    .filter(e -> (Enum)e.name().equalsIgnoreCase(dayName)).findAny().orElse(null);
    • Hmmm... Le values() méthode n'est pas disponible pour le enumType paramètre, qui est de type Class<T>.
    • J'avais pensé que c'était le nom enum. J'ai changé d'utiliser enum dans l'exemple.
    InformationsquelleAutor sprinter
  3. 6

    À partir de la version 3.8 apache commons-lang EnumUtils a deux pratique des méthodes pour cela:

    • getEnumIgnoreCase(final Class<E> enumClass, final String enumName)
    • isValidEnumIgnoreCase(final Class<E> enumClass, final String enumName)
    • Je ne vois pas de 3,8 dans le repository maven.
    InformationsquelleAutor Enigo
  4. 5

    Une solution générique serait de keeo à la convention qui constantes sont en majuscules. (Ou, dans votre cas, utilisez un capitaliser sur la chaîne).

    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");
    • Peut être, mais ce n'est pas toujours possible, parce que nous n'avons pas toujours le contrôle sur qui écrit l'enum. 🙂
    InformationsquelleAutor Joop Eggen
  5. 5

    Pour Android et relativement court, les Énumérations, je fais de la simple boucle et de comparer le nom d'ignorer le cas.

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

    Vous pouvez utiliser Classdu getEnumConstants() méthode, qui retourne un tableau de tous les types enum, si le Class représente un enum, ou null si ce n'.

    Renvoie les éléments de cette classe enum ou null si la valeur de cet objet de Classe ne représente pas un type enum.

    Optimisé pour la boucle de la ligne devrait ressembler à ceci:

    for (T d : enumType.getEnumConstants()) {
    • Oui, c'est une bonne solution. Je devrais avoir regardé dans la Catégorie<T> class, en plus Enum<T>. Merci.
    InformationsquelleAutor rgettman
  7. 1

    et qu'il mettrait en œuvre exactement la fonctionnalité de la Journée.lookup()
    méthode pour n'importe quel enum, sans avoir besoin de ré-écrire la même méthode pour
    chaque enum.

    Probablement, vous pouvez écrire une classe utilitaire pour faire comme les suivantes. 

    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
}

    Il aurait été agréable si il y avait un moyen en Java pour la prolongation de la classe Enum par implicitement l'ajout de méthodes juste la façon dont les valeurs de() la méthode est ajouté, mais je ne pense pas qu'il existe un moyen de le faire.

    InformationsquelleAutor Nandana
  8. 0

    Je suis à l'aide de cette façon comparaison insensible à la casse d'une chaîne à une enum de java
    Day[] days = Day.values();
    for(Day day: days) {
    System.out.println("MONDAY".equalsIgnoreCase(day.name()));
    }

    • Pouvez-vous expliquer que d'autres, comme les autres réponses aussi le faire?
    • Si vous imprimez à Jour.Du lundi.nom() ce, vous donnera "lundi".
    • Et pouvez-vous encore vous expliquer plus en détails ce que tu veux dire par "comme"? Pouvez-vous mettre cela dans un contexte, comme la plupart des autres réponses aussi le faire?
    InformationsquelleAutor Atul Jain