Obtendo todos os nomes em um enum como uma String []

Qual é a maneira mais fácil e / ou curta possível de obter os nomes dos elementos enum como um array de Strings?

O que quero dizer com isso é que se, por exemplo, eu tivesse o seguinte enum:

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

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

o names()método retornaria a matriz { "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }.

Aqui está uma linha para qualquer enumclasse:

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

O pré Java 8 ainda é de uma linha, embora menos elegante:

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

Que você chamaria assim:

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

Se você deseja algo simples para uma classe enum codificada:

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

Crie uma String[]matriz para os nomes e chame o values()método estático que retorna todos os valores enum e, em seguida, itere sobre os valores e preencha a matriz de nomes.

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

Aqui está uma solução elegante usando Apache Commons Lang 3 :

EnumUtils.getEnumList(State.class)

Embora retorne uma lista, você pode converter a lista facilmente com list.toArray()

Se você pode usar Java 8, isso funciona bem (alternativa à sugestão de Yura, mais eficiente):

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

Com java 8:

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

Eu escreveria assim

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

Algo assim faria:

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

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

  return names;
}

A documentação recomenda o uso em toString()vez de name()na maioria dos casos , mas você pediu explicitamente o nome aqui.

Outras maneiras:

Primeiro

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

Outro jeito

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

Minha solução, com manipulação de strings (não é a mais rápida, mas é compacta):

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

Eu faria assim (mas provavelmente faria dos nomes um conjunto não modificável em vez de uma matriz):

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

Tenho a mesma necessidade e uso um método genérico (dentro de uma 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;
}

E basta definir um ESTÁTICO dentro do enum ...

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

Enums Java realmente perdem os métodos names () e get (index), eles são muito úteis.

a maneira comum (trocadilho intencional):

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

Fiz um pequeno teste na solução do @Bohemian. O desempenho é melhor ao usar o loop ingênuo.

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

Se você quiser o mais curto, você pode tentar

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

Apenas um pensamento: talvez você não precise criar um método para retornar os valores do enum como um array de strings.

Por que você precisa do array de strings? Talvez você só precise converter os valores ao usá-los, se precisar fazer isso.

Exemplos:

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

Outra maneira de fazer isso no Java 7 ou anterior seria usar o Guava:

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

Experimente isto:

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

Você pode colocar valores enum em uma lista de strings e convertê-los em array:

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

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

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

A maneira mais fácil:

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

Onde a categoria é o Enumnome