Alle Namen in einer Aufzählung als String abrufen []

Was ist der einfachste und / oder kürzeste Weg, um die Namen von Enum-Elementen als Array von Strings zu erhalten?

Damit meine ich, dass ich zum Beispiel die folgende Aufzählung hätte:

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

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

Die names()Methode würde das Array zurückgeben { "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }.

Hier ist ein Einzeiler für jede enumKlasse:

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

Pre Java 8 ist immer noch ein Einzeiler, wenn auch weniger elegant:

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

Das würdest du so nennen:

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

Wenn Sie nur etwas Einfaches für eine fest codierte Enum-Klasse möchten:

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

Erstellen Sie ein String[]Array für die Namen und rufen Sie die statische values()Methode auf, die alle Aufzählungswerte zurückgibt. Durchlaufen Sie dann die Werte und füllen Sie das Namensarray.

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

Hier ist eine elegante Lösung mit Apache Commons Lang 3 :

EnumUtils.getEnumList(State.class)

Obwohl eine Liste zurückgegeben wird, können Sie die Liste problemlos mit konvertieren list.toArray()

Wenn Sie Java 8 verwenden können, funktioniert dies gut (Alternative zu Yuras Vorschlag, effizienter):

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

Mit Java 8:

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

Ich würde es so schreiben

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

So etwas würde reichen:

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

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

  return names;
}

Die Dokumentation empfiehlt die Verwendung toString()statt name()in den meisten Fällen , aber Sie haben für den Namen hier ausdrücklich gefragt.

Andere Möglichkeiten:

Erster

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

Andere Weise

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

Meine Lösung mit Manipulation von Strings (nicht die schnellste, aber kompakte):

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

Ich würde es so machen (aber ich würde wahrscheinlich Namen zu einer nicht veränderbaren Menge anstelle eines Arrays machen):

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

Ich habe das gleiche Bedürfnis und verwende eine generische Methode (innerhalb einer ArrayUtils-Klasse):

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

Und definieren Sie einfach eine STATIK in der Aufzählung ...

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

Java-Enums vermissen wirklich eine names () - und get (index) -Methode, sie sind wirklich hilfreich.

der gewöhnliche Weg (Wortspiel beabsichtigt):

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

Ich habe ein bisschen an der Lösung von @ Bohemian getestet. Die Leistung ist besser, wenn stattdessen eine naive Schleife verwendet wird.

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

Wenn Sie das kürzeste wollen, können Sie es versuchen

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

Nur ein Gedanke: Vielleicht müssen Sie keine Methode erstellen, um die Werte der Aufzählung als Array von Zeichenfolgen zurückzugeben.

Warum brauchen Sie eine Reihe von Zeichenfolgen? Möglicherweise müssen Sie die Werte nur konvertieren, wenn Sie sie verwenden, wenn Sie dies jemals tun müssen.

Beispiele:

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

Eine andere Möglichkeit, dies in Java 7 oder früher zu tun, wäre die Verwendung von Guava:

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

Versuche dies:

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

Sie können Enum-Werte in die Liste der Zeichenfolgen einfügen und in ein Array konvertieren:

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

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

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

Der einfachste Weg:

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

Wobei Kategorie EnumName ist