Cerca enum Java per valore stringa



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

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?




Un'altra utility che cattura in modo inverso. Usando un valore che identifica Enum, non dal suo nome.

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.EnumSet;

public class EnumUtil {

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose a 
     * public method return value of this Enum is 
     * equal to <code>valor</code>.<br/>
     * Such method should be unique public, not final and static method 
     * declared in Enum.
     * In case of more than one method in match those conditions
     * its first one will be chosen.
     * 
     * @param enumType
     * @param value
     * @return 
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value) {
        String methodName = getMethodIdentifier(enumType);
        return from(enumType, value, methodName);
    }

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose  
     * public method <code>methodName</code> return is 
     * equal to <code>value</code>.<br/>
     *
     * @param enumType
     * @param value
     * @param methodName
     * @return
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value, String methodName) {
        EnumSet<E> enumSet = EnumSet.allOf(enumType);
        for (E en : enumSet) {
            try {
                String invoke = enumType.getMethod(methodName).invoke(en).toString();
                if (invoke.equals(value.toString())) {
                    return en;
                }
            } catch (Exception e) {
                return null;
            }
        }
        return null;
    }

    private static String getMethodIdentifier(Class<?> enumType) {
        Method[] methods = enumType.getDeclaredMethods();
        String name = null;
        for (Method method : methods) {
            int mod = method.getModifiers();
            if (Modifier.isPublic(mod) && !Modifier.isStatic(mod) && !Modifier.isFinal(mod)) {
                name = method.getName();
                break;
            }
        }
        return name;
    }
}

Esempio:

public enum Foo {
    ONE("eins"), TWO("zwei"), THREE("drei");

    private String value;

    private Foo(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

EnumUtil.from(Foo.class, "drei") restituisce Foo.THREE , perché utilizzerà getValue per far corrispondere "drei", che è un metodo pubblico, non definitivo e non statico in Foo. Nel caso in cui Foo abbia più di un metodo pubblico, non finale e non statico, ad esempio getTranslate che restituisce "drei", è possibile utilizzare l'altro metodo: EnumUtil.from(Foo.class, "drei", "getTranslate") .




public static MyEnum getFromValue(String value) {
    MyEnum resp = null;
    MyEnum nodes[] = values();
    for(int i = 0; i < nodes.length; i++) {
        if(nodes[i].value.equals(value)) {
            resp = nodes[i];
            break;
        }
    }
    return resp;
}



In Java 8 il pattern Mappa statico è ancora più semplice ed è il mio metodo preffered. Se vuoi usare Enum con Jackson puoi sovrascrivere toString e usarlo al posto del nome, quindi annotare con @JsonValue

public enum MyEnum {
    BAR,
    BAZ;
    private static final Map<String, MyEnum> MAP = Stream.of(MyEnum.values()).collect(Collectors.toMap(Enum::name, Function.identity()));
    public static MyEnum fromName(String name){
        return MAP.get(name);
    }
}

public enum MyEnumForJson {
    BAR("bar"),
    BAZ("baz");
    private static final Map<String, MyEnumForJson> MAP = Stream.of(MyEnumForJson.values()).collect(Collectors.toMap(Object::toString, Function.identity()));
    private final String value;

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

    @JsonValue
    @Override
    public String toString() {
        return value;
    }

    public static MyEnumForJson fromValue(String value){
        return MAP.get(value);
    }
}



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.




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 .




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




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

}



Soluzione utilizzando le librerie Guava. Il metodo getPlanet () non fa distinzione tra maiuscole e minuscole, quindi getPlanet ("MerCUrY") restituirà Planet.MERCURY.

package com.universe.solarsystem.planets;
import org.apache.commons.lang3.StringUtils;
import com.google.common.base.Enums;
import com.google.common.base.Optional;

//Pluto and Eris are dwarf planets, who cares!
public enum Planet {
   MERCURY,
   VENUS,
   EARTH,
   MARS,
   JUPITER,
   SATURN,
   URANUS,
   NEPTUNE;

   public static Planet getPlanet(String name) {
      String val = StringUtils.trimToEmpty(name).toUpperCase();
      Optional <Planet> possible = Enums.getIfPresent(Planet.class, val);
      if (!possible.isPresent()) {
         throw new IllegalArgumentException(val + "? There is no such planet!");
      }
      return possible.get();
   }
}



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



Usa il modello di Joshua Bloch, Effective Java :

(semplificato per brevità)

enum MyEnum {
  ENUM_1("A"),
  ENUM_2("B");

  private String name;

  private static final Map<String,MyEnum> ENUM_MAP;

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

  public String getName() {
    return this.name;
  }

  // Build an immutable map of String name to enum pairs.
  // Any Map impl can be used.

  static {
    Map<String,MyEnum> map = new ConcurrentHashMap<String,MyEnum>();
    for (MyEnum instance : MyEnum.values()) {
      map.put(instance.getName(),instance);
    }
    ENUM_MAP = Collections.unmodifiableMap(map);
  }

  public static MyEnum get (String name) {
    return ENUM_MAP.get(name);
  }
}

Vedi anche:

Oracle Java Example usando Enum e Map delle istanze

Ordine di esecuzione di blocchi statici in un tipo Enum

Come posso cercare un enum Java dal suo valore di stringa




Links



Tags

java java   enums