Cómo reimplementar valueof en la enumeración

Question

Necesito volver a implementar el método enum.valueof de algunas de mis enumeraciones para que ya no arrojen excepciones, en su lugar, simplemente devuelven null si no existe un valor en la enumeración.

Estoy intentando el básico

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

pero no está funcionando, diciendo que necesito para anular o aplicar un tipo súper.

Creo que se me ocurre una súper clase, pero no estoy seguro de cómo armar esto. ¿Algunas ideas?

Answer 1

No puede. Tendrás que definir otro método diferente. El método valueOf es generado automáticamente por el compilador.

public static MyEnum permissiveValueOf(String name) { 
    for (MyEnum e : values()) { 
     if (e.name().equals(name)) { 
      return e; 
     } 
    } 
    return null; 
} 

Answer 2

Puede considerar crear un nuevo método estático (diferente nombre como convertir) en sus clases enum.

public enum MyEnum{ 
     .... 

    public static MyEnum convert(Object value){ 
     ... 
    } 
} 

Answer 3

¿Es absolutamente necesario que el método se llama valueOf como el método que tienen las enumeraciones de forma automática? En el proyecto en el que estoy trabajando tenemos métodos similares, pero los llamamos de manera diferente; por ejemplo, forName:

public static ESomeEnum forName(String name) { 
    for (ESomeEnum e : ESomeEnum.values()) { 
     if (e.name().equals(name)) { 
      return e; 
     } 
    } 

    return null; 
} 

Answer 4

Uso de Apache Commons Lang:

MyEnum myEnum = EnumUtils.getEnum(MyEnum.class, "MY_ENUM_VALUE"); 

Presupuesto de la Javadoc for EnumUtils.getEnum:

Obtiene la enumeración de la clase, devolviendo un valor nulo si no se encuentra.

Este método difiere de Enum.valueOf (java.lang.Class, java.lang.String), ya que no produce una excepción para un nombre de enumeración no válido.

Answer 5

No tiene que sobrescribir valueOf. Esto es lo que hice:

Tuve que "analizar" algunas cadenas en las enumeraciones y no coincidían con sus nombres de declaración, así que hice una especie de reimplementación de valueOf(String name).

public enum Command { 
    DIR("DIR"), 
    PUT("PUT"), 
    GET("GET"), 
    OK("OK"), 
    ERROR("ERROR"), 
    READY("READY"), 
    FIN("#FIN#"); 

    private String name; 

    private Command(final String name) { 
     this.name = name; 
    } 

    /** 
    * Returns the desired Enum or throws an exception 
    * @param commandName - String with the name contained by the Enum that you want 
    * @return Command 
    */ 
    public static Command getEnum(String commandName){ 
     // if the string is "#FIN#" returns Command.FIN. 
     if(FIN.toString().equals(commandName)){ 
      return FIN; 
     } 
     // if the name matches any of the remaining enums return whichever one matches 
     else if(Arrays.asList(Command.values()).contains(Command.valueOf(commandName))){ 
      return Command.valueOf(commandName); 
     } 
     // if it still wasn't found, throw an exception 
     throw new IllegalArgumentException("No enum defined for this string: " + commandName); 
    } 

    @Override 
    public String toString(){ 
      return name; 
     } 
    } 

Este código ha sido probado y funciona.

Se puede utilizar como:

Command k = Command.getEnum("#FIN#"); 
System.out.println(k.name() + " " +k.toString()); 
k = Command.getEnum("PUT"); 
System.out.println(k.name() + " " +k.toString()); 

Y es la salida sería:

FIN #FIN# 
PUT PUT 

espero que ayude.