Использование значений Enum в качестве строковых литералов
Каков наилучший способ использовать значения, хранящиеся в Enum, как строковые литералы? Например:
public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3
}
Тогда позже я мог бы использовать Mode.mode1 вернуть свое строковое представление как mode1, Без необходимости звонить Mode.mode1.toString(),
20 ответов
Ты не можешь Я думаю, что у вас есть четыре варианта здесь. Все четыре предлагают решение, но с немного другим подходом...
Вариант первый: использовать встроенный 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;
}
}
Вариант третий: использовать статические финалы вместо перечислений:
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() { }
}
Вариант четвертый: интерфейсы имеют каждое поле public, static и final:
public interface Modes {
String MODE_1 = "Fancy Mode 1";
String MODE_2 = "Fancy Mode 2";
String MODE_3 = "Fancy Mode 3";
}
Каждое перечисление имеет метод name() и метод valueOf(String). Первый возвращает строковое имя перечисления, а второй дает значение перечисления, именем которого является строка. Это то, что вы ищете?
String name = Modes.mode1.name();
Modes mode = Modes.valueOf(name);
В самом Enum есть также статическое значение Of(Class, String), так что вы также можете использовать
Modes mode = Enum.valueOf(Modes.class, name);
Вы можете переопределить 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
}
Как упоминает Бенни Нойгебауэр, вы можете перезаписать 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();
}
}
Вы также можете добавить статический метод для извлечения всех полей, их печати и т. Д. Просто вызовите getValue, чтобы получить строку, связанную с каждым элементом Enum.
mode1.name() или же String.valueOf(mode1), Боюсь, лучше не станет
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;
}
}
Насколько я знаю, единственный способ получить имя будет
Mode.mode1.name();
Однако если вам это действительно нужно, вы можете сделать:
public enum Modes {
mode1 ("Mode1"),
mode2 ("Mode2"),
mode3 ("Mode3");
private String name;
private Modes(String s) {
name = s;
}
}
Ты можешь использовать Mode.mode1.name() однако вам часто не нужно этого делать.
Mode mode =
System.out.println("The mode is "+mode);
Мое решение для вашей проблемы!
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!");
}
}
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 {
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())
и увидеть вывод: a
Этот метод должен работать с любым 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();
}
}
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 enum Modes {
some-really-long-string,
mode1,
mode2,
mode3;
String str;
Modes(){
this.str = super.name();
}
@Override
@NonNull
public String toString() {
return str;
}
однако - это может сработать, когда вам нужно использовать String в журнале /println или всякий раз, когда 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());
Modes.MODE1.toString();
Это простой способ без создания интерфейса, установки классов или методов установки
Вы можете попробовать это:
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 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";
}
}