web-dev-qa-db-fra.com

obtenir le nom enum de la valeur enum

J'ai beaucoup lu sur comment obtenir le nom correspondant d'un enum à partir de sa valeur en utilisant Java, mais aucun exemple ne semble fonctionner pour moi! Qu'est-ce qui ne va pas?

public class Extensions {


    public enum RelationActiveEnum
    {
        Invited(0),
        Active(1),
        Suspended(2);

        private final int value;

        private RelationActiveEnum(final int value) {
            this.value = value;
        }
    }

}

et dans une autre classe j'utilise:

        int dbValue = supp.ACTIVE;
        Extensions.RelationActiveEnum enumValue(dbValue);
        String stringName = enumValue.toString(); //Visible
        // OR
        int dbValuee = supp.ACTIVE;
        String stringValue = Enum.GetName(typeof(RelationActiveEnum), dbValue);

Je devrais travailler, non? mais ce n'est pas le cas !!!! il me dit que dbValue ne peut pas être lancé dans RelationActiveEnum ...

javaenums
33
Camilla

Puisque votre "valeur" correspond également à des ordinaux, vous pouvez simplement faire:

public enum RelationActiveEnum {
    Invited,
    Active,
    Suspended;

    private final int value;

    private RelationActiveEnum() {
        this.value = ordinal();
    }
}

Et obtenir un enum de la valeur:

int value = 1;
RelationActiveEnum enumInstance = RelationActiveEnum.values()[value];

Je suppose qu'une méthode statique serait un bon endroit pour mettre ceci:

public enum RelationActiveEnum {
     public static RelationActiveEnum fromValue(int value) 
             throws IllegalArgumentException {
         try {
              return RelationActiveEnum.values()[value]
         } catch(ArrayIndexOutOfBoundsException e) {
              throw new IllegalArgumentException("Unknown enum value :"+ value);
         }
     }
}

Évidemment, tout cela s'effondre si votre "valeur" n'est pas la même valeur que l'énuminal.

36
Gareth Davis

Disons que nous avons:

public enum MyEnum {
  Test1, Test2, Test3
}

Pour obtenir le nom d'une variable enum, utilisez name() :

MyEnum e = MyEnum.Test1;
String name = e.name(); // Returns "Test1"

Pour obtenir l'énumération d'un nom (chaîne), utilisez valueOf() :

String name = "Test1";
MyEnum e = Enum.valueOf(MyEnum.class, name);

Si vous souhaitez que les valeurs integer correspondent aux champs enum, développez la classe enum:

public enum MyEnum {
  Test1(1), Test2(2), Test3(3);

  public final int value;

  MyEnum(final int value) {
     this.value = value;
  }
}

Maintenant vous pouvez utiliser:

MyEnum e = MyEnum.Test1;
int value = e.value; // = 1

Et recherchez l'énum en utilisant la valeur entière:

MyEnum getValue(int value) {
  for(MyEnum e: MyEunm.values()) {
    if(e.value == value) {
      return e;
    }
  }
  return null;// not found
}
48
Veger

Vous pouvez créer une méthode de recherche. Pas le plus efficace (selon la taille de l'énum) mais ça marche.

public static String getNameByCode(int code){
  for(RelationActiveEnum e : RelationActiveEnum.values()){
    if(code == e.value) return e.name();
  }
  return null;
}

Et appelez ça comme ça:

RelationActiveEnum.getNameByCode(3);
25
lcguida

Ce que tu peux faire c'est

RelationActiveEnum ae = Enum.valueOf(RelationActiveEnum.class,
                                     RelationActiveEnum.ACTIVE.name();

ou

RelationActiveEnum ae = RelationActiveEnum.valueOf(
                                     RelationActiveEnum.ACTIVE.name();

ou

// not recommended as the ordinal might not match the value
RelationActiveEnum ae = RelationActiveEnum.values()[
                                     RelationActiveEnum.ACTIVE.value];

Si vous souhaitez rechercher dans un champ d'une énumération, vous devez créer une collection telle qu'une liste, un tableau ou une carte.

public enum RelationActiveEnum {
    Invited(0),
    Active(1),
    Suspended(2);

    private final int code;

    private RelationActiveEnum(final int code) {
        this.code = code;
    }

    private static final Map<Integer, RelationActiveEnum> BY_CODE_MAP = new LinkedHashMap<>();
    static {
        for (RelationActiveEnum rae : RelationActiveEnum.values()) {
            BY_CODE_MAP.put(rae.code, rae);
        }
    }

    public static RelationActiveEnum forCode(int code) {
        return BY_CODE_MAP.get(code);
    }
}

vous permet d'écrire

String name = RelationActiveEnum.forCode(RelationActiveEnum.ACTIVE.code).name();
7
Peter Lawrey

Dans mon cas, la valeur n'était pas un entier mais une chaîne. La méthode getNameByCode peut être ajoutée à l'énum pour obtenir le nom d'une valeur String.

enum CODE {
    SUCCESS("SCS"), DELETE("DEL");

    private String status;

    /**
     * @return the status
     */
    public String getStatus() {
        return status;
    }

    /**
     * @param status
     *            the status to set
     */
    public void setStatus(String status) {
        this.status = status;
    }

    private CODE(String status) {
        this.status = status;
    }

    public static String getNameByCode(String code) {
        for (int i = 0; i < CODE.values().length; i++) {
            if (code.equals(CODE.values()[i].status))
                return CODE.values()[i].name();
        }
        return null;
    }
6
Mithun Khatri

Ceci est mon point de vue sur elle:

public enum LoginState { 
    LOGGED_IN(1), LOGGED_OUT(0), IN_TRANSACTION(-1);

    private int code;

    LoginState(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    public static LoginState getLoginStateFromCode(int code){
        for(LoginState e : LoginState.values()){
            if(code == e.code) return e;
        }
        return LoginState.LOGGED_OUT; //or null
    }
};

Et je l’ai utilisé avec les Préférences Système dans Android comme ceci:

LoginState getLoginState(int i) {
    return LoginState.getLoginStateFromCode(
                prefs().getInt(SPK_IS_LOGIN, LoginState.LOGGED_OUT.getCode())
            );
}

public static void setLoginState(LoginState newLoginState) {
    editor().putInt(SPK_IS_LOGIN, newLoginState.getCode());
    editor().commit();
}

où pref et editor sont SharedPreferences et un SharedPreferences.Editor

3
msysmilu

Si vous voulez quelque chose de plus efficace en condition d'exécution, vous pouvez avoir une carte contenant tous les choix possibles de l'énum en fonction de leur valeur. Mais ce sera un peu plus lent lors de l'initialisation de la machine virtuelle.

import Java.util.HashMap;
import Java.util.Map;

/**
 * Example of enum with a getter that need a value in parameter, and that return the Choice/Instance 
 * of the enum which has the same value.
 * The value of each choice can be random.
 */
public enum MyEnum {
    /** a random choice */
    Choice1(4),
    /** a nother one */
    Choice2(2),
    /** another one again */
    Choice3(9);
    /** a map that contains every choices of the enum ordered by their value. */
    private static final Map<Integer, MyEnum> MY_MAP = new HashMap<Integer, MyEnum>();
    static {
        // populating the map
        for (MyEnum myEnum : values()) {
            MY_MAP.put(myEnum.getValue(), myEnum);
        }
    }
    /** the value of the choice */
    private int value;

    /**
     * constructor
     * @param value the value
     */
    private MyEnum(int value) {
        this.value = value;
    }

    /**
     * getter of the value
     * @return int
     */
    public int getValue() {
        return value;
    }

    /**
     * Return one of the choice of the enum by its value.
     * May return null if there is no choice for this value.
     * @param value value
     * @return MyEnum
     */
    public static MyEnum getByValue(int value) {
        return MY_MAP.get(value);
    }

    /**
     * {@inheritDoc}
     * @see Java.lang.Enum#toString()
     */
    public String toString() {
        return name() + "=" + value;
    }

    /**
     * Exemple of how to use this class.
     * @param args args
     */
    public static void main(String[] args) {
        MyEnum enum1 = MyEnum.Choice1;
        System.out.println("enum1==>" + String.valueOf(enum1));
        MyEnum enum2GotByValue = MyEnum.getByValue(enum1.getValue());
        System.out.println("enum2GotByValue==>" + String.valueOf(enum2GotByValue));
        MyEnum enum3Unknown = MyEnum.getByValue(4);
        System.out.println("enum3Unknown==>" + String.valueOf(enum3Unknown));
    }
}
3
user3328716