clase - tostring java español

Reemplazar valueof() y toString() en Java enumeración

Question

Los valores en mi enum son palabras que necesitan espacios, pero las enumeraciones no pueden tener espacios en sus valores, por lo que todo está agrupado. Quiero sobrescribir toString() para agregar estos espacios donde lo diga.

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

Por ejemplo:

public enum RandomEnum
{
     StartHere,
     StopHere
}

Llamar a toString() en RandomEnum cuyo valor es StartHere devuelve la cadena "Start Here" . Call valueof() en esa misma cadena ( "Start Here" ) devuelve el valor enum StartHere .

¿Cómo puedo hacer esto?

Answer 1

¿Qué tal una implementación de Java 8? (nulo puede ser reemplazado por tu Enum predeterminado)

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

Answer 2

Aún tienes la opción de implementar en tu enum esto:

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

Answer 3

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

Answer 4

No creo que vaya a obtener valueOf ("Comience aquí") para que funcione. 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

Answer 5

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

Answer 6

Puede usar un Mapa estático en su enumeración que asigna Cadenas a las constantes enum. Úselo en un método estático ''getEnum''. Esto omite la necesidad de iterar a través de las enumeraciones cada vez que desea 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 se produzca debajo de la declaración de las constantes enum.

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

EDITAR - Por los comentarios:

1. Esta solución asume 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 enum único y no nulo, esto parece una restricción segura.
2. Agregué el método ''toSTring ()'' como se solicita en la pregunta

Answer 7

Puedes probar este código. Como no puede anular el método valueOf , tiene que definir un método personalizado ( getEnum en el código de ejemplo a continuación) que devuelve el valor que necesita y cambiar 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();
    }
}