Substituir valueof () e toString () na enumeração Java

Os valores em meu enumsão palavras que precisam ter espaços neles, mas enumerações não podem ter espaços em seus valores; portanto, tudo está agrupado. Eu quero substituir toString()para adicionar esses espaços onde eu digo.

Também quero que a enumeração forneça a enumeração correta quando uso valueOf()a mesma sequência em que adicionei os espaços.

Por exemplo:

public enum RandomEnum
{
     StartHere,
     StopHere
}

Chamada toString()em RandomEnumcujo valor é StartHereseqüência de retornos "Start Here". A chamada valueof()nessa mesma string ( "Start Here") retorna um valor de enumeração StartHere.

Como posso fazer isso?

Você pode experimentar este código. Como você não pode substituir o valueOfmétodo, é necessário definir um método personalizado ( getEnumno código de exemplo abaixo) que retorne o valor necessário e altere seu cliente para usar esse método.

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

Tente isso, mas não sei se isso funcionará em todos os lugares :)

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

Você pode usar um mapa estático em sua enumeração que mapeia Strings para constantes de enumeração. Use-o em um método estático 'getEnum'. Isso ignora a necessidade de iterar pelas enumerações sempre que você deseja obter uma do valor 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;
    }
}

Apenas verifique se a inicialização estática do mapa ocorre abaixo da declaração das constantes enum.

BTW - esse tipo 'ImmutableMap' é da API do Google goiaba, e eu definitivamente recomendo em casos como este.

EDIT - Pelos comentários:

1. Esta solução pressupõe que cada valor de sequência atribuído seja exclusivo e não nulo. Dado que o criador do enum pode controlar isso, e que a string corresponde ao valor de enum exclusivo e não nulo, isso parece uma restrição segura.
2. Adicionei o método 'toSTring ()' conforme solicitado na pergunta

Que tal uma implementação do Java 8? (null pode ser substituído pelo seu Enum padrão)

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 você pode usar:

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

Eu não acho que você vai obter valor de ("Start Here") para funcionar. Mas quanto aos espaços ... tente o seguinte ...

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

A seguir, é uma boa alternativa genérica para 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);
}

Você ainda tem uma opção para implementar em sua enumeração isso:

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