Überschreiben Sie valueof () und toString () in der Java-Enumeration

Die Werte in my enumsind Wörter, die Leerzeichen enthalten müssen, aber Enums können keine Leerzeichen in ihren Werten enthalten, sodass alles zusammengefasst ist. Ich möchte überschreiben toString(), um diese Leerzeichen dort hinzuzufügen, wo ich es sage.

Ich möchte auch, dass die Aufzählung die richtige Aufzählung liefert, wenn ich valueOf()dieselbe Zeichenfolge verwende, zu der ich die Leerzeichen hinzugefügt habe.

Beispielsweise:

public enum RandomEnum
{
     StartHere,
     StopHere
}

Rufen Sie toString()an , RandomEnumdessen Wert StartHerezurückkehrt Zeichenfolge "Start Here". Der Aufruf valueof()derselben Zeichenfolge ( "Start Here") gibt den Aufzählungswert zurück StartHere.

Wie kann ich das machen?

Sie können diesen Code ausprobieren. Da Sie die valueOfMethode nicht überschreiben können , müssen Sie eine benutzerdefinierte Methode definieren ( getEnumim folgenden Beispielcode), die den benötigten Wert zurückgibt, und Ihren Client so ändern, dass stattdessen diese Methode verwendet wird.

public enum RandomEnum {

    StartHere("Start Here"),
    StopHere("Stop Here");

    private String value;

    RandomEnum(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

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

    public static RandomEnum getEnum(String value) {
        for(RandomEnum v : values())
            if(v.getValue().equalsIgnoreCase(value)) return v;
        throw new IllegalArgumentException();
    }
}

Versuchen Sie dies, aber ich bin nicht sicher, ob das überall funktionieren wird :)

public enum MyEnum {
    A("Start There"),
    B("Start Here");

    MyEnum(String name) {
        try {
            Field fieldName = getClass().getSuperclass().getDeclaredField("name");
            fieldName.setAccessible(true);
            fieldName.set(this, name);
            fieldName.setAccessible(false);
        } catch (Exception e) {}
    }
}

Sie können in Ihrer Aufzählung eine statische Map verwenden, die Strings Enum-Konstanten zuordnet. Verwenden Sie es in einer statischen Methode 'getEnum'. Dadurch wird die Notwendigkeit übersprungen, die Aufzählungen jedes Mal zu durchlaufen, wenn Sie eine von ihrem String-Wert erhalten möchten.

public enum RandomEnum {

    StartHere("Start Here"),
    StopHere("Stop Here");

    private final String strVal;
    private RandomEnum(String strVal) {
        this.strVal = strVal;
    }

    public static RandomEnum getEnum(String strVal) {
        if(!strValMap.containsKey(strVal)) {
            throw new IllegalArgumentException("Unknown String Value: " + strVal);
        }
        return strValMap.get(strVal);
    }

    private static final Map<String, RandomEnum> strValMap;
    static {
        final Map<String, RandomEnum> tmpMap = Maps.newHashMap();
        for(final RandomEnum en : RandomEnum.values()) {
            tmpMap.put(en.strVal, en);
        }
        strValMap = ImmutableMap.copyOf(tmpMap);
    }

    @Override
    public String toString() {
        return strVal;
    }
}

Stellen Sie einfach sicher, dass die statische Initialisierung der Karte unterhalb der Deklaration der Enum-Konstanten erfolgt.

Übrigens - dieser 'ImmutableMap'-Typ stammt aus der Google Guava-API, und ich empfehle ihn auf jeden Fall in solchen Fällen.

BEARBEITEN - Gemäß den Kommentaren:

1. Diese Lösung setzt voraus, dass jeder zugewiesene Zeichenfolgenwert eindeutig und nicht null ist. Angesichts der Tatsache, dass der Ersteller der Aufzählung dies steuern kann und die Zeichenfolge dem eindeutigen und nicht null Aufzählungswert entspricht, scheint dies eine sichere Einschränkung zu sein.
2. Ich habe die in der Frage angeforderte Methode 'toSTring ()' hinzugefügt

Wie wäre es mit einer Java 8-Implementierung? (null kann durch Ihre Standardaufzählung ersetzt werden)

public static RandomEnum getEnum(String value) {
    List<RandomEnum> list = Arrays.asList(RandomEnum.values());
    return list.stream().filter(m -> m.value.equals(value)).findAny().orElse(null);
}

Oder Sie könnten verwenden:

...findAny().orElseThrow(NotFoundException::new);

Ich glaube nicht, dass Sie valueOf ("Start Here") zum Laufen bringen werden. Aber was die Leerzeichen betrifft ... versuchen Sie Folgendes ...

static private enum RandomEnum {
    R("Start There"), 
    G("Start Here"); 
    String value;
    RandomEnum(String s) {
        value = s;
    }
}

System.out.println(RandomEnum.G.value);
System.out.println(RandomEnum.valueOf("G").value);

Start Here
Start Here

Das Folgende ist eine nette generische Alternative zu valueOf ()

public static RandomEnum getEnum(String value) {
  for (RandomEnum re : RandomEnum.values()) {
    if (re.description.compareTo(value) == 0) {
      return re;
    }
  }
  throw new IllegalArgumentException("Invalid RandomEnum value: " + value);
}

Sie haben noch die Möglichkeit, Folgendes in Ihre Aufzählung zu implementieren:

public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name){...}