114

将枚举元素的名称作为 s 数组获取的最简单和/或最短的方法String是什么？

我的意思是，例如，如果我有以下枚举：

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

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

该names()方法将返回数组{ "NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED" }。

4

26 回答 26

115

这是任何enum课程的单线：

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

Pre Java 8 仍然是单行的，尽管不那么优雅：

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

你会这样称呼：

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

如果您只想为硬编码的枚举类做一些简单的事情：

public static String[] names() {
    return Arrays.toString(State.values()).replaceAll("^.|.$", "").split(", ");
}
于 2012-12-09T01:18:46.163 回答
64

为名称创建一个String[]数组并调用返回所有枚举值的静态values()方法，然后遍历这些值并填充名称数组。

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;
}
于 2012-12-09T00:09:23.300 回答
18

这是使用Apache Commons Lang 3的优雅解决方案：

EnumUtils.getEnumList(State.class)

虽然它返回一个列表，但您可以轻松地转换列表list.toArray()

于 2016-03-01T08:50:37.707 回答
16

如果您可以使用 Java 8，则效果很好（替代 Yura 的建议，效率更高）：

public static String[] names() {
    return Stream.of(State.values()).map(State::name).toArray(String[]::new);
}
于 2015-06-02T05:16:45.313 回答
11

使用 Java 8：

Arrays.stream(MyEnum.values()).map(Enum::name)
                    .collect(Collectors.toList()).toArray();
于 2015-03-03T09:22:45.370 回答
6

我会这样写

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()]);
}
于 2014-04-04T11:55:31.250 回答
4

另一种方法：

第一

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

另一种方式

Stream.of(FieldType.values()).map(f -> f.toString()).toArray(String[]::new);
于 2017-08-10T08:39:01.010 回答
3

这样的事情会做：

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

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

  return names;
}

文档建议在大多数情况下使用toString()而不是name()，但您已在此处明确要求提供名称。

于 2012-12-09T00:15:24.463 回答
2

我会这样做（但我可能会将名称设为不可修改的集合而不是数组）：

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));
    }
}
于 2012-12-09T01:07:40.740 回答
2

我的解决方案，通过字符串操作（不是最快的，但很紧凑）：

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(",");
    }
}
于 2012-12-09T03:25:49.153 回答
2

普通方式（双关语）：

String[] myStringArray=new String[EMyEnum.values().length];
for(EMyEnum e:EMyEnum.values())myStringArray[e.ordinal()]=e.toString();
于 2016-09-15T01:29:32.483 回答
2

得到了简单的解决方案

Arrays.stream(State.values()).map(Enum::name).collect(Collectors.toList())
于 2021-02-05T05:37:37.333 回答
1

我有同样的需要并使用通用方法（在 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;
}

只需在枚举中定义一个 STATIC ...

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

Java 枚举真的错过了 names() 和 get(index) 方法，它们真的很有帮助。

于 2015-04-07T05:09:34.380 回答
1

org.apache.commons.lang3.EnumUtils.getEnumMap(State.class).keySet()

于 2016-04-12T11:04:14.927 回答
1

我对@Bohemian 的解决方案做了一些测试。改用朴素循环时性能更好。

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);
}
于 2016-11-04T10:12:33.107 回答
1

与接受的答案非常相似，但自从我了解了 EnumSet，我忍不住到处使用它。因此，对于更简洁的（Java8）答案：

public static String[] getNames(Class<? extends Enum<?>> e) {
  return EnumSet.allOf(e).stream().map(Enum::name).toArray(String[]::new);
}
于 2020-10-30T18:05:07.257 回答
0

如果你想要最短的你可以试试

public static String[] names() {
    String test = Arrays.toString(values());
    return text.substring(1, text.length()-1).split(", ");
}
于 2012-12-09T00:28:39.380 回答
0

只是一个想法：也许您不需要创建一个方法来将枚举的值作为字符串数组返回。

为什么需要字符串数组？如果您需要这样做，也许您只需要在使用它们时转换这些值。

例子：

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()));
于 2012-12-09T03:53:28.393 回答
0

试试这个：

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;
}
于 2015-05-18T15:48:33.220 回答
0

在 Java 7 或更早版本中执行此操作的另一种方法是使用 Guava：

public static String[] names() {
    return FluentIterable.from(values()).transform(Enum::name).toArray(String.class);
}
于 2018-10-12T09:19:28.667 回答
0

您可以将枚举值放入字符串列表并转换为数组：

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

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

    String[] stateArray = new String[stateList.size()];
    stateArray = stateList.toArray(stateArray);
于 2019-11-09T07:31:33.350 回答
0

最简单的方法：

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

类别是Enum名称

于 2019-12-09T15:40:41.567 回答
0

您可以通过“Enum::name”获取枚举字符串值

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

此实现不需要额外的“功能”和“字段”。只需添加此功能即可获得您想要的结果。

于 2021-02-05T05:56:08.217 回答
0

根据 Bohemian 对 Kotlin 的回答：

使用replace()而不是replaceAll().

Arrays.toString(MyEnum.values()).replace(Regex("^.|.$"), "").split(", ").toTypedArray()

旁注：例如，转换为.toTypedArray()用于AlertDialog's setSingleChoiceItems。

于 2021-02-20T03:19:37.937 回答
0 
enum CardType {
    CLUB, DIAMOND, HEART, SPADE;

}

public class Control {
    public static void main(String[] args) {

        String[] cardsArray = new String[CardType.values().length];
        int i = 0;

        for (CardType cardType : CardType.values()){
            cardsArray[i] = cardType.name();
            i++;
        }
        //to output the array
        for (int j = 0; j < CardType.values().length; j++){
            System.out.println(cardsArray[j]);
        }
    }
}
于 2021-03-30T15:34:24.223 回答
0

您不需要使用Streams API或Apache Commons库。这里可以说是最简单和最快的方法：

public static String[] names() {
    String[] names = new String[State.values().length];
    State[] values = State.values();
    for (int i = 0, valuesLength = values.length; i < valuesLength; i++) {
        names[i] = values[i].toString();
    }
    return names;
}
于 2021-04-23T10:22:04.010 回答