Obtener todos los nombres en una enumeración como una cadena []

¿Cuál es la forma más fácil y / o más corta posible de obtener los nombres de los elementos enum como una matriz de Strings?

Lo que quiero decir con esto es que si, por ejemplo, tuviera la siguiente enumeración:

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

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

el names()método devolvería la matriz { "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }.

Aquí hay una sola línea para cualquier enumclase:

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

Pre Java 8 sigue siendo de una sola línea, aunque menos elegante:

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

Que llamarías así:

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

Si solo desea algo simple para una clase de enumeración codificada:

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

Cree una String[]matriz para los nombres y llame al values()método estático que devuelve todos los valores de enumeración, luego itere sobre los valores y complete la matriz de nombres.

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

Aquí tienes una solución elegante usando Apache Commons Lang 3 :

EnumUtils.getEnumList(State.class)

Aunque devuelve una lista, puede convertir la lista fácilmente con list.toArray()

Si puede usar Java 8, esto funciona bien (alternativa a la sugerencia de Yura, más eficiente):

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

Con java 8:

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

Lo escribiria asi

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 como esto haría:

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

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

  return names;
}

La documentación recomienda usar en toString()lugar de name()en la mayoría de los casos , pero ha pedido explícitamente el nombre aquí.

Otras formas:

El primero

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

Otra manera

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

Mi solución, con manipulación de cadenas (no es la más rápida, pero es 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(",");
    }
}

Lo haría de esta manera (pero probablemente convertiría los nombres en un conjunto no modificable en lugar de una 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));
    }
}

Tengo la misma necesidad y uso un método genérico (dentro de una clase 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;
}

Y simplemente defina una ESTÁTICA dentro de la enumeración ...

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

Las enumeraciones de Java realmente extrañan los métodos de names () y get (index), son realmente útiles.

la forma ordinaria (juego de palabras intencionado):

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

Hice una pequeña prueba en la solución de @ Bohemian. El rendimiento es mejor cuando se usa un bucle ingenuo.

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 quieres lo más corto puedes probar

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

Solo un pensamiento: tal vez no necesite crear un método para devolver los valores de la enumeración como una matriz de cadenas.

¿Por qué necesita la matriz de cadenas? Tal vez solo necesite convertir los valores cuando los use, si alguna vez necesita hacerlo.

Ejemplos:

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

Otra forma de hacerlo en Java 7 o anterior sería usar Guava:

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

Prueba esto:

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

Puede poner valores de enumeración en la lista de cadenas y convertirlos en una matriz:

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

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

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

La forma más fácil:

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

Donde Categoría es Enumnombre