使用Enum值作为字符串字面量

mode1.name()或String.valueOf(mode1)。恐怕没有比这更好的了

你可以使用Mode.mode1.name()，但是你通常不需要这样做。

Mode mode =
System.out.println("The mode is "+mode);

据我所知，唯一的办法就是

Mode.mode1.name();

然而，如果你真的需要这样做，你可以这样做:

public enum Modes {
mode1 ("Mode1"),
mode2 ("Mode2"),
mode3 ("Mode3");


private String name;


private Modes(String s) {
name = s;
}
}

Enum是一个有点特殊的类。枚举可以存储额外的字段，实现方法等。例如

public enum Modes {
mode1('a'),
mode2('b'),
mode3('c'),
;
char c;


private Modes(char c) {
this.c = c;
}
public char character() {
return c;
}
}

现在你可以说:

System.out.println(Modes.mode1.character())

and see output: a < / p >

每个枚举都有name()和valueOf(String)方法。前者返回enum的字符串名称，后者给出名称为该字符串的enum值。这就是你要找的吗?

String name = Modes.mode1.name();
Modes mode = Modes.valueOf(name);

在Enum本身上还有一个静态valueOf(Class, String)，所以你还可以使用:

Modes mode = Enum.valueOf(Modes.class, name);

你不能。我认为你有四个选择。这四家公司都提供了解决方案，但方法略有不同。

选项一: 在枚举上使用内置的name()。如果您不需要任何特殊的命名格式，这是非常好的。

    String name = Modes.mode1.name(); // Returns the name of this enum constant, exactly as declared in its enum declaration.

选项二: 如果需要更多的控制，可以向枚举添加覆盖属性

public enum Modes {
mode1 ("Fancy Mode 1"),
mode2 ("Fancy Mode 2"),
mode3 ("Fancy Mode 3");


private final String name;


private Modes(String s) {
name = s;
}


public boolean equalsName(String otherName) {
// (otherName == null) check is not needed because name.equals(null) returns false
return name.equals(otherName);
}


public String toString() {
return this.name;
}
}

选项3: 使用静态韵母代替枚举:

public final class Modes {


public static final String MODE_1 = "Fancy Mode 1";
public static final String MODE_2 = "Fancy Mode 2";
public static final String MODE_3 = "Fancy Mode 3";


private Modes() { }
}

选项4: 接口的每个字段都是public、static和final:

public interface Modes {


String MODE_1 = "Fancy Mode 1";
String MODE_2 = "Fancy Mode 2";
String MODE_3 = "Fancy Mode 3";
}

你可以为每个枚举值重写toString()方法。

例子:

public enum Country {


DE {
@Override
public String toString() {
return "Germany";
}
},
IT {
@Override
public String toString() {
return "Italy";
}
},
US {
@Override
public String toString() {
return "United States";
}
}


}

用法:

public static void main(String[] args) {
System.out.println(Country.DE); // Germany
System.out.println(Country.IT); // Italy
System.out.println(Country.US); // United States
}

正如Benny Neugebauer提到的，您可以覆盖toString()。然而，取而代之的是为每个枚举字段重写toString，我更喜欢这样:

public enum Country{
SPAIN("España"),
ITALY("Italia"),
PORTUGAL("Portugal");




private String value;


Country(final String value) {
this.value = value;
}


public String getValue() {
return value;
}


@Override
public String toString() {
return this.getValue();
}
}

你可以简单地使用:

""+ Modes.mode1

我的解决方案!

import java.util.HashMap;
import java.util.Map;


public enum MapEnumSample {
Mustang("One of the fastest cars in the world!"),
Mercedes("One of the most beautiful cars in the world!"),
Ferrari("Ferrari or Mercedes, which one is the best?");


private final String description;
private static Map<String, String> enumMap;


private MapEnumSample(String description) {
this.description = description;
}


public String getEnumValue() {
return description;
}


public static String getEnumKey(String name) {
if (enumMap == null) {
initializeMap();
}
return enumMap.get(name);
}


private static Map<String, String> initializeMap() {
enumMap = new HashMap<String, String>();
for (MapEnumSample access : MapEnumSample.values()) {
enumMap.put(access.getEnumValue(), access.toString());
}
return enumMap;
}


public static void main(String[] args) {


// getting value from Description
System.out.println(MapEnumSample.getEnumKey("One of the fastest cars in the world!"));


// getting value from Constant
System.out.println(MapEnumSample.Mustang.getEnumValue());


System.out.println(MapEnumSample.getEnumKey("One of the most beautiful cars in the world!"));
System.out.println(MapEnumSample.Mercedes.getEnumValue());


// doesnt exist in Enum
System.out.println("Mustang or Mercedes, which one is the best?");
System.out.println(MapEnumSample.getEnumKey("Mustang or Mercedes, which one is the best?") == null ? "I don't know!" : "I believe that "
+ MapEnumSample.getEnumKey("Ferrari or Mustang, which one is the best?") + " is the best!.");


// exists in Enum
System.out.println("Ferrari or Mercedes, wich one is the best?");
System.out.println(MapEnumSample.getEnumKey("Ferrari or Mercedes, which one is the best?") == null ? "I don't know!" : "I believe that "
+ MapEnumSample.getEnumKey("Ferrari or Mercedes, which one is the best?") + " is the best!");


}
}

package com.common.test;


public  enum Days {




monday(1,"Monday"),tuesday(2,"Tuesday"),wednesday(3,"Wednesday"),
thrusday(4,"Thrusday"),friday(5,"Friday"),saturday(6,"Saturday"),sunday(7,"Sunday");


private int id;
private String desc;




Days(int id,String desc){
this.id=id;
this.desc=desc;
}


public static String getDay(int id){


for (Days day : Days.values()) {
if (day.getId() == id) {
return day.getDesc();
}
}
return null;
}


public int getId() {
return id;
}


public void setId(int id) {
this.id = id;
}


public String getDesc() {
return desc;
}


public void setDesc(String desc) {
this.desc = desc;
}






};

经过多次尝试，我终于想出了这个解决办法

public static enum Operation {


Addition, Subtraction, Multiplication, Division,;


public String getUserFriendlyString() {
if (this==Addition) {
return " + ";
} else if (this==Subtraction) {
return " - ";
} else if (this==Multiplication) {
return " * ";
} else if (this==Division) {
return " / ";
}
return "undefined";
}
}

public enum Modes {
MODE1("Mode1"),
MODE2("Mode2"),
MODE3("Mode3");


private String value;
public String getValue() {
return value;
}
private Modes(String value) {
this.value = value;
}
}

你可以像下面这样调用任何你想从枚举中获取字符串值的地方。

Modes.MODE1.getvalue();

这将返回“Mode1”作为字符串。

对于我的枚举，我真的不喜欢把它们分配给每个1个字符串。这就是我如何在枚举上实现toString()方法。

enum Animal
{
DOG, CAT, BIRD;
public String toString(){
switch (this) {
case DOG: return "Dog";
case CAT: return "Cat";
case BIRD: return "Bird";
}
return null;
}
}

此方法应该适用于任何enum:

public enum MyEnum {
VALUE1,
VALUE2,
VALUE3;


public int getValue() {
return this.ordinal();
}


public static DataType forValue(int value) {
return values()[value];
}


public String toString() {
return forValue(getValue()).name();
}
}

public enum Environment
{
PROD("https://prod.domain.com:1088/"),
SIT("https://sit.domain.com:2019/"),
CIT("https://cit.domain.com:8080/"),
DEV("https://dev.domain.com:21323/");


private String url;


Environment(String envUrl) {
this.url = envUrl;
}


public String getUrl() {
return url;
}
}


String prodUrl = Environment.PROD.getUrl();

它将打印:

https://prod.domain.com:1088/

Enum字符串常量的这种设计在大多数情况下都有效。

你可以试试这个:

public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3;


public String toString(){
switch(this) {
case some-really-long-string:
return "some-really-long-string";
case mode2:
return "mode2";
default: return "undefined";
}
}

｝

我发现这个更容易防止输入错误:

public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3;


String str;


Modes(){
this.str = super.name();
}


@Override
@NonNull
public String toString() {
return str;
}

然而，当你需要在log/println上使用String时，或者当java自动编译toString()方法时，这可能会起作用，但在这样的代码行中->

// sample method that require (string,value)
intent.putExtra(Modes.mode1 ,shareElement.getMode()); // java error
// first argument enum does not return value

相反，如上所述，你仍然必须扩展枚举，并在这些情况下使用.name() :

intent.putExtra(Modes.mode1.name() ,shareElement.getMode());

使用mode1.name()或String.valueOf(Modes.mode1)