स्ट्रिंग को एनम वैल्यू से तुलना करने का सही तरीका क्या है?

Question

गृहकार्य: रॉक पेपर कैंची खेल। - कंप्यूटर या मानव

 enum Gesture{ROCK,PAPER,SCISSORS}; 

जहाँ से मैं तय करने के लिए जो जीतता है मानों की तुलना करना चाहते हैं:

मैं एक गणन बना लिया है। मूल्यों को सेट करना ठीक काम करता है, और तुलना ठीक से काम करती है (पेपर कवर रॉक, रॉक क्रश कैंची, कैंची पेपर कटौती)। हालांकि, मैं काम करने के लिए अपनी टाई नहीं मिल सकता है। किसी भी समय टाई होने पर उपयोगकर्ता को विजेता घोषित किया जाता है।

आह ... बकवास ... यह स्पष्ट होगा: userPick मूल्यों rock, paper, या scissors के साथ एक String है। userPick से computerPick की तुलना करने के लिए मैं == का उपयोग करने में असमर्थ हूं, जैसा कि आप नीचे देख सकते हैं, को enum से Gesture टाइप किया गया है।

 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.... 

मैं अनुमान लगा रहा हूँ वहाँ rockROCK के बराबर नहीं किया जा रहा है, या क्योंकि बाद एक String नहीं है String userPick नहीं Gesture computerPick मिलान करने में सक्षम होने के साथ एक मुद्दा है कि। हालांकि, मैं अपनी पाठ्यपुस्तक या ओरेकल के जावा ट्यूटोरियल में एक समान परिस्थिति का उदाहरण नहीं ढूंढ पा रहा हूं, इसलिए मुझे यकीन नहीं है कि समस्या को कैसे ठीक किया जाए ...

कोई संकेत?

Answer 1

मैं आपके प्रश्न से एकत्र कर रहा हूं कि userPickString मान है। एक तरफ

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

एक के रूप में, अगर आप की गारंटी है कि computer हमेशा से एक मान 1, 2, या 3 (और कुछ नहीं), आप इसे एक Gesture enum करने के लिए परिवर्तित कर सकते हैं: आप इस तरह यह तुलना कर सकते हैं साथ:

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

Answer 2

आप toString() और enum में valueOf() प्रणाली की घोषणा करनी चाहिए।

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

Answer 3

आप नीचे दिए गए की तरह एक आसान तरीका में कर सकते हैं,:

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

Answer 4

यह साफ हो रहा है।

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

और फिर मुख्य कोड में:

String airplane="BOEING_747"; 

if(Plane.BOEING_747.equalsIgnoreCase(airplane)){ 
    //code 
} 

Answer 5

आप के रूप में पालन करें एक enum आइटम के लिए एक स्ट्रिंग तुलना कर सकते हैं,

सार्वजनिक वर्ग मुख्य {

enum IaaSProvider{ 
    aws, 
    microsoft, 
    google 
} 

public static void main(String[] args){ 

    IaaSProvider iaaSProvider = IaaSProvider.google; 

    if("google".equals(iaaSProvider.toString())){ 
     System.out.println("The provider is google"); 
    } 

} 

}

Answer 6

मेरा विचार:

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

और यू लिख यू की जांच करने के लिए चाहते हैं:

SomeKindOfEnum.ENUM_NAME.equalValue("initialValue") 

किंडा मेरे लिए अच्छा लग रहा है :)। शायद किसी को यह उपयोगी लगेगा।

Answer 7

GestureTypes के एक स्थिर आयात कर रहा है और फिर इसे बहुत क्लीनर

enum GestureTypes{ROCK,PAPER,SCISSORS}; 

और

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 
} 

}

Answer 8

परिभाषित enum लग बना सकता है valuesOf() विधि का उपयोग कर:

public enum Gesture 
{ 
    ROCK, PAPER, SCISSORS; 
} 

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

    return false; 
} 

और इसका इस्तेमाल करते हैं:एक विधि enum सामग्री की जांच करने के लिए परिभाषित

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