web-dev-qa-db-fra.com

Quelle est la bonne façon de comparer une chaîne à une valeur enum?

Homework: Rock Paper Scissors jeu.

J'ai créé une énumération:

      enum Gesture{ROCK,PAPER,SCISSORS};

à partir de laquelle je veux comparer les valeurs pour décider qui gagne - ordinateur ou humain. Le réglage des valeurs fonctionne très bien et les comparaisons fonctionnent correctement (le papier couvre le caillou, le caillou écrase les ciseaux, les ciseaux coupent le papier). Cependant, je ne peux pas obtenir ma cravate au travail. L'utilisateur est déclaré gagnant à chaque fois qu'il y a égalité.

Ahhh ... merde ... cela clarifiera: userPick est un String avec les valeurs rock, paper ou scissors. Je ne peux pas utiliser == pour comparer userPick à computerPick, qui, comme vous pouvez le voir ci-dessous, est converti en type Gesture à partir de mon enum.

      if(computer == 1)
         computerPick = Gesture.ROCK;
      else
         if(computer == 2)
           computerPick = Gesture.PAPER;
         else
           computerPick = Gesture.SCISSORS;
      if(userPick.equals(computerPick))
       {
          msg = "tie";
          ++tieGames;
       }
           etc....

Je suppose qu’il ya un problème avec rock qui n’est pas égal à ROCK, ou le String userPick ne pouvant pas correspondre à Gesture computerPick parce que ce dernier n’est pas un String. Cependant, je ne suis pas en mesure de trouver un exemple d'une situation similaire dans mon manuel ou dans les tutoriels Java d'Oracle) d'Oracle. Je ne suis donc pas sûr de savoir comment résoudre le problème ...

Des allusions?

javaenums
37
dwwilson66

Je comprends de votre question que userPick est une valeur de String. Vous pouvez le comparer comme ceci:

if (userPick.equalsIgnoreCase(computerPick.name())) . . .

En passant, si vous êtes assuré que computer est toujours une des valeurs 1, 2, ou 3 _ (et rien d’autre), vous pouvez le convertir en un Gesture enum avec:

Gesture computerPick = Gesture.values()[computer - 1];
44
Ted Hopp

Vous devez déclarer la méthode toString() et valueOf() dans enum.

 import Java.io.Serializable;

public enum Gesture implements Serializable {
    ROCK,PAPER,SCISSORS;

    public String toString(){
        switch(this){
        case ROCK :
            return "Rock";
        case PAPER :
            return "Paper";
        case SCISSORS :
            return "Scissors";
        }
        return null;
    }

    public static Gesture valueOf(Class<Gesture> enumType, String value){
        if(value.equalsIgnoreCase(ROCK.toString()))
            return Gesture.ROCK;
        else if(value.equalsIgnoreCase(PAPER.toString()))
            return Gesture.PAPER;
        else if(value.equalsIgnoreCase(SCISSORS.toString()))
            return Gesture.SCISSORS;
        else
            return null;
    }
}
21
kandarp

Mon idée:

public enum SomeKindOfEnum{
    ENUM_NAME("initialValue");

    private String value;

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

    public boolean equalValue(String passedValue){
        return this.value.equals(passedValue);
    }
}

Et si vous voulez vérifier la valeur, écrivez:

SomeKindOfEnum.ENUM_NAME.equalValue("initialValue")

Kinda a l'air sympa pour moi :). Peut-être que quelqu'un le trouvera utile.

6
Crushnik

Vous pouvez le faire d'une manière plus simple, comme ci-dessous:

boolean IsEqualStringandEnum (String str,Enum enum)
{
  if (str.equals(enum.toString()))
     return true;
  else
     return false;
}
2
oiyio
public class Main {

    enum Vehical{
        Car,
        Bus,
        Van
    }

    public static void main(String[] args){

      String vehicalType = "CAR";

        if(vehicalType.equals(Vehical.Car.name())){
            System.out.println("The provider is Car");
        }

     String vehical_Type = "BUS";

       if(vehical_Type.equals(Vehical.Bus.toString())){
            System.out.println("The provider is Bus");
        }


    }
}
2
Srikanth

Définir enum:

public enum Gesture
{
    ROCK, PAPER, SCISSORS;
}

Définissez une méthode pour vérifier enum content:

private boolean enumContainsValue(String value)
{
    for (Gesture gesture : Gesture.values())
    {
        if (gesture.name().equals(value))
        {
            return true;
        }
    }

    return false;
}

Et utilisez-le:

String gestureString = "PAPER";

if (enumContainsValue(gestureString))
{
    Gesture gestureId = Gesture.valueOf("PAPER");

    switch (gestureId)
    {
        case ROCK:
            Log.i("TAG", "ROCK");
            break;

        case PAPER:
            Log.i("TAG", "PAPER");
            break;

        case SCISSORS:
            Log.i("TAG", "SCISSORS");
            break;
    }
}
2
Ayaz Alifov

Effectuer une importation statique des types de mouvements, puis utiliser les valeurs de la méthode Of () pourrait lui donner un aspect beaucoup plus net:

enum GestureTypes{ROCK,PAPER,SCISSORS};

et

import static com.example.GestureTypes.*;
public class GestureFactory {

    public static Gesture getInstance(final String gesture) {
        if (ROCK == valueOf(gesture))
            //do somthing
        if (PAPER == valueOf(gesture))
            //do somthing
    }
}
1
User2709

Cela semble être propre.

public enum Plane{

/**
 * BOEING_747 plane.
 */
BOEING_747("BOEING_747"),

/**
 * AIRBUS_A380 Plane.
 */
AIRBUS_A380("AIRBUS_A380"),

;

private final String plane;       

private Plane(final String plane) {
    this.plane= plane;
}

Plane(){ 
    plane=null; 
}


/**
 * toString method.
 * 
 * @return Value of this Enum as String.
 */
@Override
public String toString(){
   return plane;
}

/**
 * This method add support to compare Strings with the equalsIgnoreCase String method.
 * 
 * Replicated functionality of the equalsIgnorecase of the Java.lang.String.class
 * 
 * @param value String to test.
 * @return True if equal otherwise false.
 */
public boolean equalsIgnoreCase(final String value){
    return plane.equalsIgnoreCase(value);
}

Et puis dans le code principal:

String airplane="BOEING_747";

if(Plane.BOEING_747.equalsIgnoreCase(airplane)){
     //code
}
0
Rami Del Toro