Was ist der beste Weg, um die in einem Enum gespeicherten Werte als String-Literale zu verwenden? Zum Beispiel:
public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3
}
Später könnte ich dann Mode.mode1
verwenden, um seine Zeichenfolgendarstellung als mode1
zurückzugeben. Ohne ständig Mode.mode1.toString()
anrufen zu müssen.
Du kannst nicht Ich denke, Sie haben hier VIER Möglichkeiten. Alle vier bieten eine Lösung, jedoch mit einem etwas anderen Ansatz.
Option Eins: Verwenden Sie die integrierte name()
in einer Aufzählung. Dies ist vollkommen in Ordnung, wenn Sie kein spezielles Namensformat benötigen.
String name = Modes.mode1.name(); // Returns the name of this enum constant, exactly as declared in its enum declaration.
Option Zwei: füge überschreibende Eigenschaften zu deinen Aufzählungen hinzu, wenn du mehr Kontrolle haben möchtest
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;
}
}
Option Drei: statische Finals anstelle von Aufzählungen verwenden:
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() { }
}
Option 4: Schnittstellen haben alle Felder public, static und final:
public interface Modes {
String MODE_1 = "Fancy Mode 1";
String MODE_2 = "Fancy Mode 2";
String MODE_3 = "Fancy Mode 3";
}
Jedes Enum verfügt über eine name () - und eine valueOf (String) -Methode. Ersteres gibt den Stringnamen der Aufzählung zurück, und Letzteres gibt den Aufzählungswert an, dessen Name der String ist. Suchst du so?
String name = Modes.mode1.name();
Modes mode = Modes.valueOf(name);
Es gibt auch einen statischen valueOf (Class, String) in Enum selbst, so dass Sie es auch verwenden können
Modes mode = Enum.valueOf(Modes.class, name);
Sie können die toString()
-Methode für jeden Aufzählungswert überschreiben.
Beispiel:
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";
}
}
}
Verwendungszweck:
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
}
mode1.name()
oder String.valueOf(mode1)
. Besser geht es nicht, ich habe Angst
Wie Benny Neugebauer erwähnt, könnten Sie den toString () überschreiben. Statt jedoch den toString für jedes Aufzählungsfeld zu überschreiben, gefällt mir Folgendes:
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();
}
}
Sie können auch eine statische Methode hinzufügen, um alle Felder abzurufen, um sie alle auszudrucken usw. Rufen Sie einfach getValue auf, um den String zu erhalten, der jedem Enum-Element zugeordnet ist
public enum Modes {
MODE1("Mode1"),
MODE2("Mode2"),
MODE3("Mode3");
private String value;
public String getValue() {
return value;
}
private Modes(String value) {
this.value = value;
}
}
sie können wie unten beschrieben anrufen, wo immer Sie den Wert als Zeichenfolge aus der Aufzählung erhalten möchten.
Modes.MODE1.getvalue();
Dies gibt "Mode1" als String zurück.
Sie können Mode.mode1.name()
verwenden, dies ist jedoch häufig nicht erforderlich.
Mode mode =
System.out.println("The mode is "+mode);
Soweit ich weiß, ist der einzige Weg, um den Namen zu bekommen
Mode.mode1.name();
Wenn Sie es wirklich so brauchen, können Sie Folgendes tun:
public enum Modes {
mode1 ("Mode1"),
mode2 ("Mode2"),
mode3 ("Mode3");
private String name;
private Modes(String s) {
name = s;
}
}
Sie können einfach verwenden:
""+ Modes.mode1
Für meine Aufzählungen mag ich nicht wirklich daran denken, dass ihnen jeweils 1 String zugewiesen wird. So implementiere ich eine toString () -Methode in Enums.
enum Animal
{
DOG, CAT, BIRD;
public String toString(){
switch (this) {
case DOG: return "Dog";
case CAT: return "Cat";
case BIRD: return "Bird";
}
return null;
}
}
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;
}
};
Enum ist nur eine kleine Sonderklasse. Enums können zusätzliche Felder speichern, Methoden implementieren usw. Zum Beispiel
public enum Modes {
mode1('a'),
mode2('b'),
mode3('c'),
;
char c;
private Modes(char c) {
this.c = c;
}
public char character() {
return c;
}
}
Nun können Sie sagen:
System.out.println(Modes.mode1.character())
und siehe Ausgabe: a
Diese Methode sollte mit jeder enum
funktionieren:
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();
}
}
meine Lösung für dein Problem!
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();
Es wird gedruckt:
https://prod.domain.com:1088/
Dieses Design für enum-String-Konstanten funktioniert in den meisten Fällen.
Modes.MODE1.toString();
Dies ist ein einfacher Weg, ohne Interface-, Klassen- oder Getter-Setter zu erstellen
ich fand, dass dies einfacher ist, um Tippfehler zu vermeiden:
public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3;
String str;
Modes(){
this.str = super.name();
}
@Override
@NonNull
public String toString() {
return str;
}
dies kann jedoch funktionieren, wenn Sie einen String in einem Protokoll/Ausdruck verwenden müssen oder wenn Java die toString () -Methode automatisch kompiliert, jedoch in einer Codezeile wie dieser ->
// sample method that require (string,value)
intent.putExtra(Modes.mode1 ,shareElement.getMode()); // Java error
// first argument enum does not return value
stattdessen müssen Sie, wie oben erwähnt, die Aufzählung erweitern und verwenden .name()
in diesen Fällen wie folgt:
intent.putExtra(Modes.mode1.name() ,shareElement.getMode());
Sie können dies versuchen:
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";
}
}
}
nach vielen Versuchen bin ich mit dieser Lösung gekommen
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";
}
}