Reemplazar valueof () y toString () en Java enum

Los valores en my enumson palabras que necesitan tener espacios en ellos, pero las enumeraciones no pueden tener espacios en sus valores, por lo que todo está agrupado. Quiero anular toString()para agregar estos espacios donde se lo indique.

También quiero que la enumeración proporcione la enumeración correcta cuando la uso valueOf()en la misma cadena a la que agregué los espacios.

Por ejemplo:

public enum RandomEnum
{
     StartHere,
     StopHere
}

La llamada toString()en RandomEnumcuyo valor es StartHeredevuelve cadena "Start Here". Llamada valueof()en esa misma cadena ( "Start Here") devuelve valor de enumeración StartHere.

¿Cómo puedo hacer esto?

Puedes probar este código. Como no puede anular el valueOfmétodo, debe definir un método personalizado ( getEnumen el código de muestra a continuación) que devuelve el valor que necesita y cambia su cliente para utilizar este 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();
    }
}

Prueba esto, pero no estoy seguro de que funcione en todos lados :)

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

Puede usar un mapa estático en su enumeración que asigna cadenas a constantes de enumeración. Úselo en un método estático 'getEnum'. Esto evita la necesidad de recorrer las enumeraciones cada vez que desee obtener una de su valor de cadena.

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

Solo asegúrese de que la inicialización estática del mapa ocurra debajo de la declaración de las constantes enum.

Por cierto, ese tipo 'ImmutableMap' es de la API de guayaba de Google, y definitivamente lo recomiendo en casos como este.

EDITAR - Por los comentarios:

1. Esta solución supone que cada valor de cadena asignado es único y no nulo. Dado que el creador de la enumeración puede controlar esto, y que la cadena corresponde al valor de enumeración único y no nulo, esto parece una restricción segura.
2. Agregué el método 'toSTring ()' como se solicitó en la pregunta

¿Qué tal una implementación de Java 8? (nulo puede ser reemplazado por su enumeración predeterminada)

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

O podrías usar:

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

No creo que vayas a obtener valueOf ("Comience aquí") para trabajar. Pero en cuanto a espacios ... intente lo siguiente ...

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

La siguiente es una buena alternativa genérica 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);
}

Todavía tiene una opción para implementar en su enumeración esto:

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