Verwenden von Enum-Werten als String-Literale

Was ist der beste Weg, um die in einer Aufzählung gespeicherten Werte als String-Literale zu verwenden? Zum Beispiel:

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

Dann später könnte ich verwenden Mode.mode1, um seine Zeichenfolgendarstellung als zurückzugeben mode1. Ohne weiter anrufen zu müssen Mode.mode1.toString().

Das kannst du nicht. Ich denke, Sie haben hier VIER Optionen. Alle vier bieten eine Lösung, aber mit einem etwas anderen Ansatz ...

Option Eins: Verwenden Sie die in name()einer Aufzählung integrierte Funktion. 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 2: Fügen Sie Ihren Aufzählungen übergeordnete Eigenschaften hinzu, wenn Sie mehr Kontrolle wünschen

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 3: Verwenden Sie statische Finals anstelle von Aufzählungen:

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 jedes Feld öffentlich, statisch und endgültig:

public interface Modes {

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

Jede Aufzählung hat sowohl eine name () - als auch eine valueOf (String) -Methode. Ersteres gibt den Zeichenfolgennamen der Aufzählung zurück, und letzteres gibt den Aufzählungswert an, dessen Name die Zeichenfolge ist. Ist das wie das, wonach Sie suchen?

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

Es gibt auch einen statischen valueOf (Class, String) in Enum selbst, den Sie auch verwenden können

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

Sie könnten das überschreiben toString() Methode für jeden Aufzählungswert .

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
}

Wie Benny Neugebauer erwähnt, könnten Sie den toString () überschreiben. Anstatt jedoch den toString für jedes Enum-Feld zu überschreiben, gefällt mir eher 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, alle zu drucken usw. Rufen Sie einfach getValue auf, um die Zeichenfolge zu erhalten, die jedem Enum-Element zugeordnet ist

mode1.name()oder String.valueOf(mode1). Besser geht es leider nicht

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 einen Aufruf wie unten ausführen, 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 verwenden Mode.mode1.name(), müssen dies jedoch häufig nicht tun.

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

Soweit ich weiß, wäre der einzige Weg, den Namen zu bekommen, der

Mode.mode1.name();

Wenn Sie es jedoch 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;
    }
}

Für meine Enums denke ich nicht wirklich gerne daran, dass ihnen jeweils 1 String zugewiesen wird. So implementiere ich eine toString () -Methode für 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;
    }
}

Sie können einfach verwenden:

""+ Modes.mode1

meine Lösung für Ihr 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!");

    }
}

Enum ist nur eine kleine Sonderklasse. Aufzählungen 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;
    }
}

Jetzt können Sie sagen:

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

und siehe Ausgabe: a

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



};

Diese Methode sollte mit folgenden Methoden funktionieren 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();

Es wird gedruckt:

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

Dieses Design für Enum-String-Konstanten funktioniert in den meisten Fällen.

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

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

}}

Ich fand, dass dies einfacher ist, um Typfehler zu verhindern:

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 für ein Protokoll / einen Druck verwenden müssen oder wenn Java die toString () -Methode automatisch kompiliert, jedoch für eine Codezeile wie diese ->

// 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 noch erweitern und .name() in folgenden Fällen verwenden:

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