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

Quel est le moyen le plus simple et / ou le plus court possible d'obtenir les noms des éléments enum sous forme de 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 names()méthode renverrait le tableau { "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }.

Voici une ligne pour toutes les enumclasses:

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

Pre Java 8 est toujours un one-liner, bien que moins élégant:

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

Que vous appelleriez comme ceci:

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

Si vous voulez juste quelque chose de simple pour une classe enum codée en dur:

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

Créez un String[]tableau pour les noms et appelez la values()méthode statique qui renvoie toutes les valeurs d'énumération, 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;
}

Voici une solution élégante utilisant Apache Commons Lang 3 :

EnumUtils.getEnumList(State.class)

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

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

Avec java 8:

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

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()]);
}

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.

Un autre moyen:

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

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

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

J'ai le même besoin et j'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 définissez simplement un STATIC à 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 get (index), elles sont vraiment utiles.

la manière ordinaire (jeu de mots):

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

J'ai fait un petit test sur la solution de @ Bohemian. Les performances sont meilleures lorsque vous utilisez une boucle naïve à la place.

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

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

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

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

Pourquoi avez-vous besoin du tableau de chaînes? Peut-être que vous n'avez besoin de convertir les valeurs que lorsque vous les utilisez, si jamais vous en avez besoin.

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

Une autre façon de le faire dans Java 7 ou une version antérieure serait d'utiliser Guava:

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

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

Vous pouvez mettre des valeurs d'énumération dans une liste de chaînes et les convertir en tableau:

    List<String> stateList = new ArrayList<>();

            for (State state: State.values()) {
                stateList.add(state.toString());
            }

    String[] stateArray = new String[stateList.size()];
    stateArray = stateList.toArray(stateArray);

Le moyen le plus simple:

Category[] category = Category.values();
for (int i = 0; i < cat.length; i++) {
     System.out.println(i  + " - " + category[i]);
}

Où la catégorie est le Enumnom