मैं अपने स्ट्रिंग मान से जावा एनम कैसे देख सकता हूं?

Question

मैं अपने स्ट्रिंग मान (या संभवतः किसी अन्य मूल्य) से एक enum देखना चाहता हूं। मैंने निम्नलिखित कोड का प्रयास किया है लेकिन यह प्रारंभिक में स्थिर की अनुमति नहीं देता है। क्या कोई आसान तरीका है?

public enum Verbosity { 

    BRIEF, NORMAL, FULL; 

    private static Map<String, Verbosity> stringMap = new HashMap<String, Verbosity>(); 

    private Verbosity() { 
     stringMap.put(this.toString(), this); 
    } 

    public static Verbosity getVerbosity(String key) { 
     return stringMap.get(key); 
    } 
}; 

Answer 1

valueOf विधि है जो स्वचालित रूप से प्रत्येक Enum लिए बनाया जाता है का उपयोग करें।

Verbosity.valueOf("BRIEF") == Verbosity.BRIEF 

मनमाने ढंग से मूल्यों के लिए शुरू के साथ:

public static Verbosity findByAbbr(String abbr){ 
    for(Verbosity v : values()){ 
     if(v.abbr().equals(abbr)){ 
      return v; 
     } 
    } 
    return null; 
} 

केवल कार्यान्वयन मानचित्र अगर आपके प्रोफाइलर आप के लिए कहता है पर ले जाने के बाद में।

मुझे पता है कि यह सभी मूल्यों पर पुनरावृत्ति कर रहा है, लेकिन केवल 3 enum मानों के साथ यह किसी भी अन्य प्रयास के लायक नहीं है, वास्तव में जब तक आपके पास बहुत सारे मूल्य नहीं हैं, तो मैं एक मानचित्र से परेशान नहीं होगा, यह पर्याप्त तेज़ होगा।

Answer 2

और आप valueOf() का उपयोग नहीं कर सकते हैं?

संपादित करें: बीटीडब्ल्यू, एक enum में स्थिर {} का उपयोग करने से आपको रोक नहीं रहा है।

Answer 3

आप करीब हैं। मनमाने ढंग से मूल्यों के लिए, निम्न की तरह कुछ प्रयास करें:

public enum Day { 

    MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"), 
    THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ; 

    private final String abbreviation; 

    // Reverse-lookup map for getting a day from an abbreviation 
    private static final Map<String, Day> lookup = new HashMap<String, Day>(); 

    static { 
     for (Day d : Day.values()) { 
      lookup.put(d.getAbbreviation(), d); 
     } 
    } 

    private Day(String abbreviation) { 
     this.abbreviation = abbreviation; 
    } 

    public String getAbbreviation() { 
     return abbreviation; 
    } 

    public static Day get(String abbreviation) { 
     return lookup.get(abbreviation); 
    } 
} 

Answer 4

@ लेल का जवाब खतरनाक है और मैंने देखा है कि यह विशेष रूप से काम नहीं करता है यदि आप enum को एक स्थिर आंतरिक कक्षा बनाते हैं। इसके बजाय मैंने इस तरह कुछ उपयोग किया है जो enums से पहले बूटस्ट्रैपसिंगटन मानचित्र लोड करेगा।

संपादितइस आधुनिक JVMs के साथ किसी भी अधिक एक समस्या (JVM 1.6 या अधिक) नहीं होना चाहिए, लेकिन मैं अभी भी JRebel में समस्याएं हैं लेकिन मैं इसे जांचना करने का मौका नहीं पड़ा है लगता है।

मुझे पहले लोड:

public final class BootstrapSingleton { 

     // Reverse-lookup map for getting a day from an abbreviation 
     public static final Map<String, Day> lookup = new HashMap<String, Day>(); 
    } 

अब enum निर्माता में लोड: (

public enum Day { 
     MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"), 
     THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ; 

     private final String abbreviation; 

     private Day(String abbreviation) { 
      this.abbreviation = abbreviation; 
      BootstrapSingleton.lookup.put(abbreviation, this); 
     } 

     public String getAbbreviation() { 
      return abbreviation; 
     } 

     public static Day get(String abbreviation) { 
      return lookup.get(abbreviation); 
     } 
    } 

आप एक आंतरिक enum है, तो आप सिर्फ enum परिभाषा ऊपर मानचित्र को परिभाषित करने और है कि कर सकते हैं में सिद्धांत) पहले लोड होना चाहिए।

Answer 5

शायद, इसे देखें। यह मेरे लिए काम कर रहा है। इसका उद्देश्य 'लाल' को '/ red_color' के साथ देखना है। static map घोषित करना और इसमें enum एस लोड करना केवल एक बार कुछ प्रदर्शन लाभ लाएगा यदि enum एस कई हैं।

public class Mapper { 

public enum Maps { 

    COLOR_RED("/red_color", "RED"); 

    private final String code; 
    private final String description; 
    private static Map<String, String> mMap; 

    private Maps(String code, String description) { 
     this.code = code; 
     this.description = description; 
    } 

    public String getCode() { 
     return name(); 
    } 

    public String getDescription() { 
     return description; 
    } 

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

    public static String getColorName(String uri) { 
     if (mMap == null) { 
      initializeMapping(); 
     } 
     if (mMap.containsKey(uri)) { 
      return mMap.get(uri); 
     } 
     return null; 
    } 

    private static void initializeMapping() { 
     mMap = new HashMap<String, String>(); 
     for (Maps s : Maps.values()) { 
      mMap.put(s.code, s.description); 
     } 
    } 
} 
} 

कृपया अपने विचारों को प्रस्तुत करें।

Answer 6

आप के रूप में ऊपर गैरेथ डेविस & ब्रैड गदा ने सुझाव दिया Enum::valueOf() फ़ंक्शन का उपयोग करें, लेकिन आप IllegalArgumentException अगर इस्तेमाल किया स्ट्रिंग enum में मौजूद नहीं है कि फेंक दिया होगा संभाल सुनिश्चित करें।

Answer 7

जावा भाषा विशिष्टता 7 में a example है!जो स्वयं के संदर्भ के साथ मानचित्र के आरंभ पर आपके प्रश्न को दर्शाता है।

Answer 8

आप नीचे दिए गए कोड के रूप में अपने Enum परिभाषित कर सकते हैं:

public enum Verbosity 
{ 
    BRIEF, NORMAL, FULL, ACTION_NOT_VALID; 
    private int value; 

    public int getValue() 
    { 
    return this.value; 
    } 

    public static final Verbosity getVerbosityByValue(int value) 
    { 
    for(Verbosity verbosity : Verbosity.values()) 
    { 
     if(verbosity.getValue() == value) 
      return verbosity ; 
    } 

    return ACTION_NOT_VALID; 
    } 

    @Override 
    public String toString() 
    { 
     return ((Integer)this.getValue()).toString(); 
    } 
}; 

See following link for more clarification

Answer 9

जावा 8 के साथ आप इस तरह से प्राप्त कर सकते:

public static Verbosity findByAbbr(final String abbr){ 
    return Arrays.stream(values()).filter(value -> value.abbr().equals(abbr)).findFirst().orElse(null); 
} 

Answer 10

मामले में यह मदद करता है अन्य, विकल्प जो मैं पसंद करता हूं, जो यहां सूचीबद्ध नहीं है,का उपयोग करता है 10:

public enum Vebosity { 
    BRIEF("BRIEF"), 
    NORMAL("NORMAL"), 
    FULL("FULL"); 

    private String value; 
    private Verbosity(final String value) { 
     this.value = value; 
    } 

    public String getValue() { 
     return this.value; 
    } 

    private static ImmutableMap<String, Verbosity> reverseLookup = 
      Maps.uniqueIndex(Arrays.asList(Verbosity.values)), Verbosity::getValue); 

    public static Verbosity fromString(final String id) { 
     return reverseLookup.getOrDefault(id, NORMAL); 
    } 
} 

डिफ़ॉल्ट आप null उपयोग कर सकते हैं के साथ

, आप throw IllegalArgumentException या अपने fromString एक Optional लौट सकते हैं कर सकते हैं, जो कुछ भी व्यवहार आप पसंद करते हैं।