Remplacer valueof () et toString () dans l'énumération Java

Les valeurs dans my enumsont des mots qui doivent contenir des espaces, mais les énumérations ne peuvent pas avoir d'espaces dans leurs valeurs, donc tout est groupé. Je veux remplacer toString()pour ajouter ces espaces là où je le dis.

Je veux également que l'énumération fournisse l'énumération correcte lorsque j'utilise valueOf()sur la même chaîne à laquelle j'ai ajouté les espaces.

Par exemple:

public enum RandomEnum
{
     StartHere,
     StopHere
}

Appel toString()sur RandomEnumdont la valeur est StartHererenvoie la chaîne "Start Here". L'appel valueof()sur cette même chaîne ( "Start Here") renvoie la valeur enum StartHere.

Comment puis-je faire ceci?

Vous pouvez essayer ce code. Étant donné que vous ne pouvez pas remplacer la valueOfméthode, vous devez définir une méthode personnalisée ( getEnumdans l'exemple de code ci-dessous) qui renvoie la valeur dont vous avez besoin et modifiez votre client pour utiliser cette méthode à la place.

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

Essayez ceci, mais je ne suis pas sûr que cela fonctionnera partout :)

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) {}
    }
}

Vous pouvez utiliser une carte statique dans votre énumération qui mappe des chaînes à des constantes d'énumération. Utilisez-le dans une méthode statique 'getEnum'. Cela évite d'avoir à parcourir les énumérations chaque fois que vous souhaitez en obtenir une à partir de sa valeur String.

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

Assurez-vous simplement que l'initialisation statique de la carte se produit sous la déclaration des constantes enum.

BTW - ce type 'ImmutableMap' provient de l'API Google guava, et je le recommande vivement dans des cas comme celui-ci.

EDIT - Par les commentaires:

1. Cette solution suppose que chaque valeur de chaîne attribuée est unique et non nulle. Étant donné que le créateur de l'énumération peut contrôler cela et que la chaîne correspond à la valeur d'énumération unique et non nulle, cela semble être une restriction sûre.
2. J'ai ajouté la méthode 'toSTring ()' comme demandé dans la question

Et une implémentation Java 8? (null peut être remplacé par votre Enum par défaut)

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

Ou vous pouvez utiliser:

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

Je ne pense pas que vous allez faire fonctionner valueOf ("Start Here"). Mais en ce qui concerne les espaces ... essayez ce qui suit ...

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

Ce qui suit est une belle alternative générique à 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);
}

Vous avez toujours une option pour implémenter dans votre énumération ceci:

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