Nhận tất cả các tên trong enum dưới dạng chuỗi []

Cách dễ nhất và / hoặc ngắn nhất có thể để lấy tên của các phần tử enum dưới dạng một mảng Strings là gì?

Ý tôi muốn nói ở đây là nếu, ví dụ, tôi có enum sau:

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

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

các names()phương pháp sẽ trở lại mảng { "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }.

Đây là một lớp lót cho bất kỳ enumlớp nào :

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

Pre Java 8 vẫn là một lớp lót, mặc dù kém thanh lịch hơn:

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

Cái mà bạn sẽ gọi như thế này:

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

Nếu bạn chỉ muốn một cái gì đó đơn giản cho một lớp enum được mã hóa cứng:

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

Tạo một String[]mảng cho các tên và gọi values()phương thức tĩnh trả về tất cả các giá trị enum, sau đó lặp qua các giá trị và điền vào mảng tên.

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

Đây là một giải pháp thanh lịch sử dụng Apache Commons Lang 3 :

EnumUtils.getEnumList(State.class)

Mặc dù nó trả về một Danh sách, bạn có thể chuyển đổi danh sách dễ dàng với list.toArray()

Nếu bạn có thể sử dụng Java 8, điều này hoạt động tốt (thay thế cho đề xuất của Yura, hiệu quả hơn):

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

Với java 8:

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

Tôi sẽ viết nó như thế này

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

Một cái gì đó như thế này sẽ làm:

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

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

  return names;
}

Tài liệu khuyến nghị sử dụng toString()thay vì name()trong hầu hết các trường hợp , nhưng bạn đã yêu cầu rõ ràng tên ở đây.

Các cách khác:

Đầu tiên

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

Cách khác

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

Giải pháp của tôi, với thao tác trên chuỗi (không phải là nhanh nhất, nhưng nhỏ gọn):

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

tôi sẽ làm theo cách này (nhưng có lẽ tôi sẽ đặt tên thành một tập hợp không thể thay đổi thay vì một mảng):

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

Tôi có cùng nhu cầu và sử dụng một phương thức chung (bên trong một lớp 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;
}

Và chỉ cần xác định một STATIC bên trong enum ...

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

Các enums trong Java thực sự bỏ sót các phương thức names () và get (index), chúng thực sự hữu ích.

theo cách thông thường (ý định chơi chữ):

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

Tôi đã thực hiện một thử nghiệm nhỏ về giải pháp của @ Bohemian. Hiệu suất tốt hơn khi sử dụng vòng lặp ngây thơ.

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

Nếu bạn muốn ngắn nhất, bạn có thể thử

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

Chỉ cần một suy nghĩ: có thể bạn không cần tạo một phương thức để trả về các giá trị của enum dưới dạng một mảng chuỗi.

Tại sao bạn cần mảng chuỗi? Có thể bạn chỉ cần chuyển đổi các giá trị khi bạn sử dụng chúng, nếu bạn cần làm điều đó.

Ví dụ:

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

Một cách khác để làm điều đó trong Java 7 hoặc phiên bản cũ hơn là sử dụng Guava:

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

Thử cái này:

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

Bạn có thể đặt các giá trị enum vào danh sách các chuỗi và chuyển đổi thành mảng:

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

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

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

Cách dễ nhất:

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

Trong đó Danh mục là Enumtên