Cómo utilizar enumeración con valores en Java

Question

Cuando intento utilizar enumeración de la tienda: "=", ">", "<", etc, que tengo:

public static enum DataValueModifier { 
    EQUAL("="), 
    GREATER_THAN(">"), 
    GREATER_EUQAL(">="), 
    LESS_THAN("<"), 
    LESS_EQUAL("<="), 
    APPRROXIMATE("~"), 
    NOT_DETERMINED("ND"); 
    private String value; 
    private DataValueModifier(String value) { 
     this.value = value; 
    } 
    public String getValue() { 
     return value; 
    } 
} 

¿Cómo se utiliza cuando trato de comparar una cadena para ver si contiene un signo "=", debo hacer:

if (dataValue.contains(DataValueModifier.EQUAL.getValue())) { 
... 
} 

Entiendo que el uso de enumeración es la mejor práctica aquí, pero esto sólo se ve tonta ... Gracias ,

David

Answer 1

En primer lugar, me mudaría la "contiene "método (o su equivalente) a la enumeración misma mediante la definición de un método isModifier.

public static enum DataValueModifier { 

    ... 

    public boolean isModifier(String modifierString) 
    { 
     return modifierString != null && value.equals(modifierString); 
    } 
} 

A continuación, el código es el siguiente lugar:

if (DataValueModifier.EQUAL.isModifier(dataValue)) 
{ 
    //... 
} 

Pero, más importante aún, ¿por qué está usando DataValue en lugar de la enumeración en el primer lugar? Si obtiene entrada de línea de comando o algo, o analiza una ecuación de cadena y luego necesita descubrir la expresión, supongo que lo entiendo. Pero si usted tiene el control del código a continuación, sólo debe comenzar con la enumeración y podrás ser capaz de decir

if (dataValueEnum == DataValueModifier.EQUAL) { 
{ 
    //... 
} 

También me gustaría considerar la adición de un método estático de la enumeración que convierte una cadena dada a la valor de enum correcto No es tan eficiente, tal vez, pero a menos que realmente te importe la eficiencia, hará que tu código sea mucho más limpio. Así que añadir este método para su enumeración:

public static DataValueModifier toDataValueModifier(String dataValue) { 
    if(EQUAL.isModifier(dataValue) { 
     return EQUAL; 
    } else if(GREATER_THAN.isModifier(dataValue) { 
     return GREATER_THAN; 
    } else if... 
     // Do this for all possible values 
    } else { 
     return UNKNOWN; 
     // Also, add an UNKNOWN to your list of enum values. 
    } 
} 

El isModifier y los métodos toDataValueModifier podría añadir un poco de código feo a su enumeración DataValueModifier, pero todo su otro código se ven muy bien. Ahora puede hacer algo como esto:.

DataValueModifier dataValueEnum = DataValueModifier.toDataValueModifier(dataValue); 
if (dataValueEnum == DataValueModifier.EQUAL) { 
    ... 
} 

o incluso

switch(DataValueModifier.toDataValueModifier(dataValue)) { 
    case EQUAL: 
     // ... 
     break; 
    case GREATER_THAN: 
     // ... 
     break; 
    case GREATER_EQUAL: 
     // ... 
     break; 
    // ... define all the cases you want 
    case UNKNOWN: 
    default: 
     // ... 
} 

Answer 2

Me gustaría utilizar un static import en estos casos.

package mypackage; 

public enum DataValueModifier 
{ 
    //your enum code 
} 

entonces ...

import static mypackage.DataValueModifier.*; 

public MyClass 
{ 

    // code blah blah blah 

    public void doIt() 
    { 
    // more code blah blah 
    if (dataValue.contains(EQUAL.getValue())) 
    { 
     //... 
    } 
    } 
} 

Es un poco más agradable.

Answer 3

Si ha definido un método boolean containedIn(String str) en su enumeración e importado sus valores de enumeración de interés (en este caso EQUAL), el uso se vería así:

if (EQUAL.containedIn(dataValue)) { 
... 
}