enums esempio classe - Come ottenere un valore enum da un valore stringa in Java?





12 Answers

Un'altra soluzione se il testo non è uguale al valore di enumerazione:

public enum Blah {
  A("text1"),
  B("text2"),
  C("text3"),
  D("text4");

  private String text;

  Blah(String text) {
    this.text = text;
  }

  public String getText() {
    return this.text;
  }

  public static Blah fromString(String text) {
    for (Blah b : Blah.values()) {
      if (b.text.equalsIgnoreCase(text)) {
        return b;
      }
    }
    return null;
  }
}
values example constructor

Dì che ho un enum che è giusto

public enum Blah {
    A, B, C, D
}

e mi piacerebbe trovare il valore enum di una stringa, ad esempio "A" che sarebbe Blah.A Come sarebbe possibile farlo?

Enum.valueOf() il metodo di cui ho bisogno? Se sì, come dovrei usare questo?




Dovresti anche stare attento al tuo caso. Lasciatemi spiegare: Blah.valueOf("A") funziona, ma Blah.valueOf("a") non funzionerà. Quindi ancora Blah.valueOf("a".toUpperCase(Locale.ENGLISH)) funzionerebbe.

modificare
Modificato toUpperCase to toUpperCase(Locale.ENGLISH) basato su tc. commento e i documenti java

edit2 Su Android dovresti usare Locale.US , come sottolinea sulai .




Ecco un metodo che può farlo per qualsiasi Enum ed è insensibile al maiuscolo / minuscolo.

/** 
 * Finds the value of the given enumeration by name, case-insensitive. 
 * Throws an IllegalArgumentException if no match is found.  
 **/
public static <T extends Enum<T>> T valueOfIgnoreCase(
        Class<T> enumeration, String name) {

    for (T enumValue : enumeration.getEnumConstants()) {
        if (enumValue.name().equalsIgnoreCase(name)) {
            return enumValue;
        }
    }

    throw new IllegalArgumentException(String.format(
        "There is no value with name '%s' in Enum %s",
        name, enumeration.getName()
    ));
}



Se non vuoi scrivere la tua utility usa la libreria guava di Google:

Enums.getIfPresent(Blah.class, "A")

A differenza della funzione java integrata, è possibile controllare se A è presente in Blah e non lancia un'eccezione.




I miei 2 centesimi qui: usando Java8 Stream + controllando una stringa esatta:

public enum MyEnum {
    VALUE_1("Super"),
    VALUE_2("Rainbow"),
    VALUE_3("Dash"),
    VALUE_3("Rocks");

    private final String value;

    MyEnum(String value) {
        this.value = value;
    }

    /**
     * @return the Enum representation for the given string.
     * @throws IllegalArgumentException if unknown string.
     */
    public static MyEnum fromString(String s) throws IllegalArgumentException {
        return Arrays.stream(MyEnum.values())
                .filter(v -> v.value.equals(s))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("unknown value: " + s));
    }
}

** MODIFICARE **

Rinominata la funzione in fromString() dopo averla denominata utilizzando tale convenzione, otterrai alcuni vantaggi dal linguaggio Java stesso; per esempio:

  1. Conversione diretta di tipi nell'annotazione HeaderParam



Un altro modo per farlo usando il metodo statico implicito name() di Enum. il nome restituirà la stringa esatta utilizzata per creare quell'enumerazione che può essere utilizzata per verificare la stringa fornita:

public enum Blah {

    A, B, C, D;

    public static Blah getEnum(String s){
        if(A.name().equals(s)){
            return A;
        }else if(B.name().equals(s)){
            return B;
        }else if(C.name().equals(s)){
            return C;
        }else if (D.name().equals(s)){
            return D;
        }
        throw new IllegalArgumentException("No Enum specified for this string");
    }
}

test:

System.out.println(Blah.getEnum("B").name());

//it will print B  B

ispirazione: 10 esempi di Enum in Java




Per aggiungere alle risposte precedenti e affrontare alcune delle discussioni su null e NPE, sto utilizzando Guava Optionals per gestire i casi assenti / non validi. Funziona perfettamente per l'analisi di parametri URI / parametri.

public enum E {
    A,B,C;
    public static Optional<E> fromString(String s) {
        try {
            return Optional.of(E.valueOf(s.toUpperCase()));
        } catch (IllegalArgumentException|NullPointerException e) {
            return Optional.absent();
        }
    }
}

Per coloro che non sono a conoscenza, ecco alcune ulteriori informazioni su come evitare null con Facoltativo: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional




Metodo O (1) ispirato al codice generato da una deriva che utilizza una hashmap.

public enum USER {
        STUDENT("jon",0),TEACHER("tom",1);

        private static final Map<String, Integer> map = new HashMap<>();

        static {
                for (USER user : EnumSet.allOf(USER.class)) {
                        map.put(user.getTypeName(), user.getIndex());
                }
        }

        public static int findIndexByTypeName(String typeName) {
                return map.get(typeName);
        }

        private USER(String typeName,int index){
                this.typeName = typeName;
                this.index = index;
        }
        private String typeName;
        private int index;
        public String getTypeName() {
                return typeName;
        }
        public void setTypeName(String typeName) {
                this.typeName = typeName;
        }
        public int getIndex() {
                return index;
        }
        public void setIndex(int index) {
                this.index = index;
        }

}



java.lang.Enum definisce diversi metodi utili, disponibili per tutti i tipi di enumerazione in Java:

  • È possibile utilizzare il metodo name() per ottenere il nome di tutte le costanti Enum. Il letterale stringa usato per scrivere le costanti enum è il loro nome.
  • Allo stesso modo il metodo values() può essere usato per ottenere una matrice di tutte le costanti Enum da un tipo Enum.
  • E per la domanda posta, è possibile utilizzare il metodo valueOf() per convertire qualsiasi costante String in Enum in Java, come mostrato di seguito.
public class EnumDemo06 {
    public static void main(String args[]) {
        Gender fromString = Gender.valueOf("MALE");
        System.out.println("Gender.MALE.name() : " + fromString.name());
    }

    private enum Gender {
        MALE, FEMALE;
    }
}

Output:
Gender.MALE.name() : MALE

In questo snippet di codice, il metodo valueOf() restituisce una costante Enum Gender.MALE, chiamando il nome che restituisce "MALE" .




Aggiunta alla risposta più votata, con un'utile utilità ...

valueOf() genera due Eccezioni diverse nei casi in cui non gradisce il suo input.

  • IllegalArgumentException
  • NullPointerExeption

Se i tuoi requisiti sono tali da non avere alcuna garanzia che la tua stringa soddisfi sicuramente un valore enum, ad esempio se i dati String provengono da un database e potrebbero contenere una vecchia versione dell'enumerazione, dovrai gestirli spesso...

Quindi ecco un metodo riutilizzabile che ho scritto che ci consente di definire un Enum predefinito da restituire se la stringa che passiamo non corrisponde.

private static <T extends Enum<T>> T valueOf( String name , T defaultVal) {
        try {
            return Enum.valueOf(defaultVal.getDeclaringClass() , name);
        } catch (IllegalArgumentException | NullPointerException e) {
            return defaultVal;
        }
    }

Usalo in questo modo:

public enum MYTHINGS {
    THINGONE,
    THINGTWO
}

public static void main(String [] asd) {
  valueOf("THINGTWO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGTWO
  valueOf("THINGZERO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGONE
}



Che dire?

public enum MyEnum {
    FIRST,
    SECOND,
    THIRD;

    public static Optional<MyEnum> fromString(String value){
        try{
            return Optional.of(MyEnum.valueOf(value));
        }catch(Exception e){
            return Optional.empty();
        }
    }
}



Mi piace usare questo tipo di processo per analizzare i comandi come stringhe nelle enumerazioni. Di solito ho una delle enumerazioni come "sconosciuta", quindi aiuta ad avere quella restituita quando gli altri non vengono trovati (anche su una base insensibile alle maiuscole e minuscole) piuttosto che null (che significa che non c'è alcun valore). Quindi io uso questo approccio.

static <E extends Enum<E>> Enum getEnumValue(String what, Class<E> enumClass) {
    Enum<E> unknown=null;
    for (Enum<E> enumVal: enumClass.getEnumConstants()) {  
        if (what.compareToIgnoreCase(enumVal.name()) == 0) {
            return enumVal;
        }
        if (enumVal.name().compareToIgnoreCase("unknown") == 0) {
            unknown=enumVal;
        }
    }  
    return unknown;
}





Related


Tags

java   enums