Comment émettre une valeur à partir d'un enum à l'autre en Java?

Comment puis-je lance une valeur de Enum1 Enum 2 en Java?
Voici un exemple de ce que je suis en train de faire :

public enum Enum1 {
  ONE,
  TWO,
  THREE;
}

public enum Enum2 {
  FOUR,
  FIVE,
  SIX;
}

Donc, je veux faire quelque chose comme ceci:

Enum2 en2 = (Enum2)ONE;

Est-il possible, et comment puis-je le faire?

Merci d'avance!

Qu'attendez-vous en2 de main quand vous en avez le "cast" Enum1.ONE - t-il?

InformationsquelleAutor Android-Droid | 2011-09-02

19

Vous ne pouvez lancer à partir d'un enum à l'autre, mais chaque enum a garanti l'ordre, et vous pouvez facilement traduire un enum pour un autre (le maintien de l'ordre). Par exemple:
```
enum E1 {
    ONE, TWO, THREE,
}

enum E2 {
    ALPHA, BETA, GAMMA,
}
```
nous pouvons traduire E1.TWO vers/à partir de E2.BETA par:
```
static E2 E1toE2(E1 value) {
    return E2.values()[value.ordinal()];
}

static E1 E2toE1(E2 value) {
    return E1.values()[value.ordinal()];
}
```
- Merci s'accoupler! Cela fonctionne!
InformationsquelleAutor Michał Šrajer
7

Il n'est pas possible. Enum1 et Enum2 sont de types différents, qui n'ont rien en commun.
- +1: les Enums en Java ne se comportent pas comme des Enums en C ou en C#. Ils ne sont pas soutenus par une constante de valeur numérique. Ils sont en fait complète des objets avec certains compilateur astuces pour leur permettre de travailler dans de commutateur de cas et de ces. Mais même si elle était comme en C, je considérerais cela comme de la conception à essayer de le faire directement à travers le cast d'un enum type à l'autre, en fonction de ce qu'ils sont censés représenter du point de vue programmation.
- Je seconde. Désireux de jeter les énumérations nous tout simplement faux.
InformationsquelleAutor Heisenbug

Vous pouvez définir une méthode dans Enum1 pour revenir au correspondant Enum2:

enum Enum1 {
    ONE {
        @Override
        public Enum2 toEnum2() {
            return Enum2.ALFA;
        }
    },
    TWO {
        @Override
        public Enum2 toEnum2() {
            return Enum2.BETA;
        }
    }
    ,
    THREE {
        @Override
        public Enum2 toEnum2() {
            return Enum2.GAMMA;
        }
    }
    ;

    public abstract Enum2 toEnum2();
}

enum Enum2 {
    ALFA, BETA, GAMMA;
}

ou, un peu plus lisible (OMI):

enum Enum1 {
    ONE(Enum2.ALFA), 
    TWO(Enum2.BETA), 
    THREE(Enum2.GAMMA);

    private final Enum2 enum2;

    private Enum1(Enum2 enum2) {
        this.enum2 = enum2;
    }

    public Enum2 toEnum2() {
        return enum2;
    }
}

enum Enum2 {
    ALFA, BETA, GAMMA;
}

EDIT:

si vous avez besoin de maintenir les 2 enums découplé, la création d'une carte contenant la cartographie de Enum1 à Enum2 (dans une 3e classe utilitaire).

InformationsquelleAutor Carlos Heuberger

5

La réponse à cette question dépend de ce que le "casting" est censé faire:

Coulée par position ordinale

Dans l'exemple fourni, il n'y a pas de points communs entre les deux séries de valeurs dans les deux Énumérations, donc je suis en supposant que l'intention était de traduire en position ordinale tels que Enum1.ONE => Enum2.FOUR, Enum1.TWO => Enum2.FIVE et Enum1.THREE => Enum2.SIX. Cela peut être fait comme suit:
```
Enum2 en2 = Enum2.values()[Enum1.ONE.ordinal()];
```
La prochaine question est de savoir comment cela peut être étendue à une fonction générique qui ferait la même chose pour toutes les deux enum types. Pas pour les timides, mais la suivante sera de faire le travail (il faut Goyave):
```
public <F extends Enum<F>> F castByOrdinal(Enum<?> e, Class<F> fClass) {
    return Iterators.get(EnumSet.allOf(fClass).iterator(), e.ordinal());
}
```
Si Google Goyave bibliothèque n'est pas présent, il peut être fait manuellement en un peu plus de lignes de code:
```
public <F extends Enum<F>> F castByOrdinal(final Enum<?> e, final Class<F> fClass) {
    final Iterator<F> iter = EnumSet.allOf(fClass).iterator();
    int count = 0;
    F fValue = null;
    while (count <= e.ordinal()) {
        if (!iter.hasNext()) {
            return null; //Or throw exception if preferred e.g. IndexOutOfBoundsException
        }
        fValue = iter.next();
        count++;
    }

    return fValue;
}
```
Exemple d'utilisation:
```
Enum2 en2 = castByOrdinal(Enum1.ONE, Enum2.class);
```
Coulée par le partage de valeur d'énumération des noms de

Il y a un autre moyen de mettre entre les énumérations qui partagent les mêmes noms de valeur:

E. g:
```
enum Shape {
    TRIANGLE, SQUARE, PENTAGON, HEXAGON, UNKNOWN, NOT_APPLICABLE
}

enum Size {
    SMALL, MEDIUM, LARGE, UNKNOWN, NOT_APPLICABLE
}
```
Ce casting ne fonctionne que pour le commun des valeurs (c'est à dire UNKNOWN et NOT_APPLICABLE ci-dessus) et peut être fait comme suit:
```
Size size = Size.valueOf(Shape.UNKNOWN.name());
```
Cette va lancer une IllegalArgumentException si le nom de la valeur n'existe pas dans la cible enum. Cette fois, le générique de la méthode peut être un peu plus simple:
```
public <F extends Enum<F>> F castByName(final Enum<?> e, final Class<F> fClass) {
    return F.valueOf(fClass, e.name());
}
```
Exemple d'utilisation:
```
Size size = castByName(Shape.UNKNOWN, Size.class);
```
- Apprécier les détails.
InformationsquelleAutor Steve Chambers
3

Vous ne pouvez pas faire cela, parce qu'ils sont des objets de classes différentes.

Vous pourriez convertir de l'un à l'autre fondée sur la valeur ordinale ou de nom, mais je l'avais question de la conception de tout programme nécessaire pour le faire.

InformationsquelleAutor parsifal
3

Vous ne pouvez pas, mais vous pouvez créer une méthode statique dans votre enums, avec un code de traduction. Mais vous devez avoir une idée claire sur les règles que vous souhaitez mettre en œuvre.
- Je ne suis pas vraiment sûr de savoir comment le faire réellement.
- il ne doit pas être une méthode statique, une méthode d'instance, serait aussi faire (accord c'est plus de travail pour maintenir le plus grand des enums). @Pompeux: les énumérations sont des objets enum Enum1 { ONE { public Enum2 toEnum2() { return Enum2.FOUR; } },... vous devez également ajouter une méthode abstraite de l'ensemble de l'enum.
InformationsquelleAutor Raveline
3

Même si ce ticket a été active tout à fait il ya un moment, je suis en ajoutant une autre possibilité:

Vous pouvez également créer une Carte par exemple comme ceci:
```
HashMap<Enum1, Enum2> e1ToE2 = new HashMap<Enum1, Enum2>();
e1ToE2.put(Enum1.ONE, Enum2.FOUR);
e1ToE2.put(Enum1.TWO, Enum2.FIVE);
```
utilisation
```
Enum2 e2 = e1ToE2.get(Enum1.ONE);
```
(+) vous n'avez pas à vérifier l'ordre de vos éléments

(+) facile à lire

(+) rapide

(-) nécessite de l'espace

Corrigez-moi si je me trompe 🙂

InformationsquelleAutor codewing
2

Une opération de cast n'est pas possible, mais vous pouvez écrire une fonction membre statique pour enum1 qui jette enum2 à enum1:
```
public static Enum1 fromEnum2(Enum2 enum2) {
    ...
}
```
Par la manière, vous pouvez attribuer un ID à chaque constante de deux énumérations qui simplifie la mise en œuvre.

Ici est un tutoriel sur la enums.

InformationsquelleAutor alfa
0

Il ne sera probablement pas vous aider, mais vous pouvez avoir
```
public enum Enum1 implements MyInterface {...}
public enum Enum2 implements MyInterface {...}
```
Nous n'avons pas assez d'informations sur ce que vous essayez de faire pour vous aider.
Il ne fait aucun sens que c'est de jeter un enum pour un autre enum.

InformationsquelleAutor toto2
0

Vous ne pouvez lancer à partir d'un enum à l'autre, mais chaque enum a garanti l'ordre, et vous pouvez facilement traduire un enum pour un autre

InformationsquelleAutor T.Harini

-1

Vous pouvez le faire en utilisant de façon simple:

 public enum number{one,two};
        public enum number1{one,two};
        public void  castTonumber1(number number){

            number1 num1 = number1.valueOf(number.one.toString());
           System.out.println( "value of number 1 is " + num1);

        }*

InformationsquelleAutor Navnath

Vous devez vous connecter pour publier un commentaire.

Coulée par position ordinale

Coulée par le partage de valeur d'énumération des noms de