Pobieranie wszystkich nazw w wyliczeniu jako String []

Jaki jest najłatwiejszy i / lub najkrótszy możliwy sposób uzyskania nazw elementów wyliczeniowych w postaci tablicy Strings?

Mam przez to na myśli to, że gdybym na przykład miał następujące wyliczenie:

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

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

names()sposób powróci tablicy { "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }.

Oto jedna linijka dla każdej enumklasy:

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

Pre Java 8 jest nadal jednolinijkowym, choć mniej eleganckim:

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

To nazwałbyś tak:

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

Jeśli potrzebujesz czegoś prostego dla zakodowanej na stałe klasy wyliczeniowej:

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

Utwórz String[]tablicę nazw i wywołaj values()metodę statyczną , która zwraca wszystkie wartości wyliczenia, a następnie wykonaj iterację po wartościach i zapełnij tablicę nazw.

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

Oto eleganckie rozwiązanie wykorzystujące Apache Commons Lang 3 :

EnumUtils.getEnumList(State.class)

Mimo że zwraca listę, możesz ją łatwo przekonwertować za pomocą list.toArray()

Jeśli możesz używać Java 8, działa to ładnie (alternatywa dla sugestii Yury, bardziej wydajna):

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

W Javie 8:

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

Napisałbym to w ten sposób

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

Coś takiego zrobiłoby:

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

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

  return names;
}

Dokumentacja zaleca używanie toString()zamiast name()w większości przypadków , ale tutaj wyraźnie poprosiłeś o podanie nazwy.

Inne sposoby:

Pierwszy

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

Inny sposób

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

Moje rozwiązanie z manipulacją strunami (nie najszybsze, ale zwarte):

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

zrobiłbym to w ten sposób (ale prawdopodobnie utworzyłbym nazwy jako niemodyfikowalny zestaw zamiast tablicy):

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

Mam taką samą potrzebę i używam metody ogólnej (wewnątrz klasy 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;
}

I po prostu zdefiniuj STATIC wewnątrz wyliczenia ...

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

Wyliczeniom Java naprawdę brakuje metod names () i get (index), są one naprawdę pomocne.

zwykły sposób (gra słów zamierzona):

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

Zrobiłem mały test na rozwiązaniu @ Bohemian. Wydajność jest lepsza, gdy zamiast tego używa się naiwnej pętli.

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

Jeśli chcesz najkrótszego, możesz spróbować

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

Tylko myśl: może nie musisz tworzyć metody zwracającej wartości wyliczenia jako tablicę ciągów.

Dlaczego potrzebujesz tablicy ciągów? Może będziesz musiał tylko przekonwertować wartości, gdy ich używasz, jeśli kiedykolwiek będziesz musiał to zrobić.

Przykłady:

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

Innym sposobem na zrobienie tego w Javie 7 lub wcześniejszej byłoby użycie Guava:

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

Spróbuj tego:

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

Możesz umieścić wartości wyliczenia na liście ciągów i przekonwertować na tablicę:

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

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

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

Najłatwiejszy sposób:

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

Gdzie Kategoria to Enumnazwa