Sostituisci valueof () e toString () nell'enumerazione Java

I valori nel mio enumsono parole che devono contenere spazi, ma le enumerazioni non possono avere spazi nei loro valori, quindi è tutto raggruppato. Voglio sovrascrivere toString()per aggiungere questi spazi dove lo dico.

Voglio anche che l'enumerazione fornisca l'enumerazione corretta quando uso valueOf()sulla stessa stringa a cui ho aggiunto gli spazi.

Per esempio:

public enum RandomEnum
{
     StartHere,
     StopHere
}

La chiamata toString()sul RandomEnumcui valore è StartHererestituisce una stringa "Start Here". La chiamata valueof()sulla stessa stringa ( "Start Here") restituisce il valore enum StartHere.

Come posso fare questo?

Puoi provare questo codice. Poiché non è possibile sovrascrivere il valueOfmetodo, è necessario definire un metodo personalizzato ( getEnumnel codice di esempio riportato di seguito) che restituisca il valore necessario e modificare il client per utilizzare invece questo metodo.

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

Prova questo, ma non sono sicuro che funzionerà ovunque :)

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

È possibile utilizzare una mappa statica nella propria enumerazione che associa le stringhe alle costanti enumerate. Usalo in un metodo statico 'getEnum'. Ciò evita la necessità di iterare le enumerazioni ogni volta che si desidera ottenerne una dal valore 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;
    }
}

Assicurati solo che l'inizializzazione statica della mappa avvenga sotto la dichiarazione delle costanti enum.

BTW - quel tipo di "ImmutableMap" proviene dall'API guava di Google e lo consiglio vivamente in casi come questo.

EDIT - Per i commenti:

1. Questa soluzione presuppone che ogni valore di stringa assegnato sia univoco e non nullo. Dato che il creatore dell'enumerazione può controllarlo e che la stringa corrisponde al valore enum univoco e non nullo, questa sembra una restrizione sicura.
2. Ho aggiunto il metodo "toSTring ()" come richiesto nella domanda

Che ne dici di un'implementazione di Java 8? (null può essere sostituito dal tuo Enum predefinito)

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

Oppure potresti usare:

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

Non credo che riuscirai a far funzionare valueOf ("Inizia qui"). Ma per quanto riguarda gli spazi ... prova quanto segue ...

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

Quella che segue è una bella alternativa generica a 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);
}

Hai ancora un'opzione per implementare nella tua enum questo:

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