web-dev-qa-db-fra.com

Obtenir tous les noms dans une énumération sous forme de chaîne []

Quel est le moyen le plus simple et/ou le plus rapide possible d’obtenir les noms des éléments enum sous la forme d’un tableau de Strings?

Ce que je veux dire par là, c'est que si, par exemple, j'avais l'énumération suivante:

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;

    public static String[] names() {
        // ...
    }
}

la méthode names() renverrait un tableau analogique à { "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }.

javaarraysenums
80
Konstantin

Mettre à jour:

En Java 8, il s’agit d’une ligne pour une classe d’énumération arbitraire utilisant un flux:

public static String[] getNames(Class<? extends Enum<?>> e) {
    return Arrays.stream(e.getEnumConstants()).map(Enum::name).toArray(String[]::new);
}

En Java 7, un peu moins élégant, mais ce one-liner fait l'affaire:

public static String[] names() {
    return Arrays.toString(State.values()).replaceAll("^.|.$", "").split(", ");
}

En outre, voici une version de cela qui fonctionnera pour any enum:

public static String[] getNames(Class<? extends Enum<?>> e) {
    return Arrays.toString(e.getEnumConstants()).replaceAll("^.|.$", "").split(", ");
}

Que tu appellerais comme ceci:

String[] names = getNames(State.class); // any other enum class will work too
71
Bohemian

Créez un tableau String[] pour les noms et appelez la méthode statique values() qui renvoie toutes les valeurs enum, puis parcourez les valeurs et remplissez le tableau de noms.

public static String[] names() {
    State[] states = values();
    String[] names = new String[states.length];

    for (int i = 0; i < states.length; i++) {
        names[i] = states[i].name();
    }

    return names;
}
62
PermGenError

Si vous pouvez utiliser Java 8, cela fonctionne bien (alternative à la suggestion de Yura, plus efficace):

public static String[] names() {
    return Stream.of(State.values()).map(State::name).toArray(String[]::new);
}
10
Kris Boyd

Voici une solution élégante utilisant Apache commons-lang3:

EnumUtils.getEnumList(State.class)

Bien qu'il retourne une liste, vous pouvez facilement convertir la liste avec list.toArray ()

9
Sergio Trapiello

Avec Java 8:

Arrays.stream(MyEnum.values()).map(Enum::name)
                    .collect(Collectors.toList()).toArray();
8
Yura Galavay

Je l'écrirais comme ça

public static String[] names() {

    Java.util.LinkedList<String> list = new LinkedList<String>();
    for (State s : State.values()) {
        list.add(s.name());
    }

    return list.toArray(new String[list.size()]);
}
5
Raymond Chenon

Quelque chose comme ça ferait:

public static String[] names() {
  String[] names = new String[values().length];
  int index = 0;

  for (State state : values()) {
    names[index++] = state.name();
  }

  return names;
}

La documentation recommande d'utiliser toString() au lieu de name() dans la plupart des cas , mais vous avez explicitement demandé le nom ici.

3
Dave Webb

Ma solution, avec manipulation de chaînes (pas la plus rapide, mais compacte):

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;

    public static String[] names() {
        String valuesStr = Arrays.toString(State.values());
        return valuesStr.substring(1, valuesStr.length()-1).replace(" ", "").split(",");
    }
}
2
ceklock

Une autre façon:

Premier

Arrays.asList(FieldType.values())
            .stream()
            .map(f -> f.toString())
            .toArray(String[]::new);

Autre façon

Stream.of(FieldType.values()).map(f -> f.toString()).toArray(String[]::new);
2
Durgpal Singh

la manière ordinaire (jeu de mots voulu):

String[] myStringArray=new String[EMyEnum.values().length];
for(EMyEnum e:EMyEnum.values())myStringArray[e.ordinal()]=e.toString();
1
Aquarius Power

je le ferais de cette façon (mais je ferais probablement des noms un ensemble non modifiable au lieu d'un tableau):

import Java.util.Arrays;
enum State {
    NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;
    public static final String[] names=new String[values().length];
    static {
        State[] values=values();
        for(int i=0;i<values.length;i++)
            names[i]=values[i].name();
    }
}
public class So13783295 {
    public static void main(String[] args) {
        System.out.println(Arrays.asList(State.names));
    }
}
1
Ray Tayek

J'ai le même besoin et utilise une méthode générique (à l'intérieur d'une classe ArrayUtils):

public static <T> String[] toStringArray(T[] array) {
    String[] result=new String[array.length];
    for(int i=0; i<array.length; i++){
        result[i]=array[i].toString();
    }
    return result;
}

Et juste définir une STATIQUE à l'intérieur de l'énumération ...

public static final String[] NAMES = ArrayUtils.toStringArray(values());

Les énumérations Java manquent vraiment les méthodes names () et (index), elles sont vraiment utiles.

1
marcolopes

J'ai fait un peu de test sur la solution de @ Bohemian. La performance est meilleure si vous utilisez une boucle naïve.

public static <T extends Enum<?>> String[] getEnumNames(Class<T> inEnumClass){
    T [] values = inEnumClass.getEnumConstants();
    int len = values.length;
    String[] names = new String[len];
    for(int i=0;i<values.length;i++){
        names[i] = values[i].name();
    }
    return names;
}

//Bohemian's solution
public static String[] getNames(Class<? extends Enum<?>> e) {
    return Arrays.stream(e.getEnumConstants()).map(Enum::name).toArray(String[]::new);
}
1
Chuck

org.Apache.commons.lang3.EnumUtils.getEnumMap (State.class) .keySet ()

0
wutzebaer

Essaye ça:

public static String[] vratAtributy(){
    String[] atributy = new String[values().length];
    for(int index = 0; index < atributy.length; index++){
        atributy[index] = **values()[index].toString();**
    }
    return atributy;
0
Matiseli

Une autre façon de le faire dans Java 7 ou plus tôt serait d'utiliser Guava:

public static String[] names() {
    return FluentIterable.from(values()).transform(Enum::name).toArray(String.class);
}
0
Justin Lee

Juste une pensée: vous n’avez peut-être pas besoin de créer une méthode pour renvoyer les valeurs de l’énum en tant que tableau de chaînes.

Pourquoi avez-vous besoin du tableau de chaînes? Peut-être avez-vous seulement besoin de convertir les valeurs lorsque vous les utilisez, si jamais vous deviez le faire.

Exemples:

for (State value:values()) {
    System.out.println(value); // Just print it.
}

for (State value:values()) {
    String x = value.toString(); // Just iterate and do something with x.
}

// If you just need to print the values:
System.out.println(Arrays.toString(State.values()));
0
ceklock

Si vous voulez le plus court, vous pouvez essayer

public static String[] names() {
    String test = Arrays.toString(values());
    return text.substring(1, text.length()-1).split(", ");
}
0
Peter Lawrey