मेरे पास एक जावा क्लास है जिसमें मैं एक एनम स्टोर करता हूं। (इस प्रश्न के निचले भाग में दिखाया गया है) इस एनम में, मेरे पास toCommaSeperatedString() नामक एक विधि है जो एनम मानों की अल्पविराम से अलग स्ट्रिंग देता है . मैं इस प्रश्न में प्रदर्शन पर कुछ जानकारी पढ़ने के बाद स्ट्रिंगबिल्डर का उपयोग कर रहा हूं यहां.

जिस तरह से मैं इस एनम के मूल्यों को अल्पविराम में परिवर्तित कर रहा हूं, ऐसा करने का सबसे प्रभावी तरीका है, और यदि हां, तो स्ट्रिंग के अंतिम चार पर अतिरिक्त अल्पविराम को हटाने का सबसे प्रभावी तरीका क्या होगा?

उदाहरण के लिए, मेरी विधि 123, 456, लौटाती है, हालांकि मैं 123, 456 पसंद करूंगा। अगर मैं वापस लौटना चाहता था PROPERTY1, PROPERTY2 मैं आसानी से अपाचे कॉमन्स लाइब्रेरी StringUtils.join() का उपयोग कर सकता था, हालांकि, जब मैं स्ट्रिंग सरणी के माध्यम से पुनरावृत्ति कर रहा हूं, तो मुझे getValue विधि को कॉल करके एक स्तर कम करने की आवश्यकता है।

public class TypeEnum {
    public enum validTypes {
        PROPERTY1("123"),
        PROPERTY2("456");

        private String value;

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

        public String getValue() {
            return value;
        }

        public static boolean contains(String type) {
            for (validTypes msgType : validTypes.values()) {
                if (msgType.value.equals(type)) {
                    return true;
                }
            }
            return false;
        }

        public static String toCommaSeperatedString() {
            StringBuilder commaSeperatedValidMsgTypes = new StringBuilder();
            for(validTypes msgType : validTypes.values()) {
                commaSeperatedValidMsgTypes.append(msgType.getValue() + ", ");
            }
            return commaSeperatedValidMsgTypes.toString();
        }
    }
}
0
DevelopingDeveloper 10 अगस्त 2017, 22:19

5 जवाब

सबसे बढ़िया उत्तर

मैं दक्षता के बारे में ज्यादा चिंता नहीं करता। ऐसा करना काफी आसान है कि यह तेज़ होगा, बशर्ते आप इसे पागल तरीके से न करें। यदि यह आपके कोड में सबसे महत्वपूर्ण प्रदर्शन बाधा है, तो मुझे आश्चर्य होगा।

मैं इसे कुछ ऐसा करूँगा:

return Arrays.stream(TypeEnum.values())
      .map(t -> t.value)
      .collect(Collectors.joining(','));

आप चाहें तो इसे कैश करें; लेकिन शायद इससे कोई बड़ा फर्क नहीं पड़ने वाला है।

18
Andy Turner 15 अक्टूबर 2018, 14:08

मुझे दिखाई देने वाली पिछली कॉमा समस्या के लिए एक सामान्य पैटर्न कुछ ऐसा है

String[] values = {"A", "B", "C"};
boolean is_first = true;
StringBuilder commaSeperatedValidMsgTypes = new StringBuilder();
for(String value : values){
    if(is_first){
        is_first = false;
    }
    else{
        commaSeperatedValidMsgTypes.append(',');
    }
    commaSeperatedValidMsgTypes.append(value);
}
System.out.println(commaSeperatedValidMsgTypes.toString());

जिसके परिणामस्वरूप

A,B,C

स्थिर अंतिम फ़ील्ड को प्रारंभ करने के लिए स्थिर ब्लॉक का उपयोग करने के उत्तरों के साथ इसे जोड़ना शायद सर्वश्रेष्ठ प्रदर्शन देगा।

2
csunday95 10 अगस्त 2017, 22:26

सबसे कुशल कोड वह कोड है जो नहीं चलता है। यह उत्तर कभी नहीं बदल सकता है, इसलिए उस कोड को चलाएं जैसा कि आपके पास एक बार एनम बनाते समय होता है। एक बार हिट लें, हर बार जब कोई इसके लिए पूछे तो गणना किए गए उत्तर को वापस कर दें। ऐसा करने में बचत लंबी अवधि में इस चिंता से कहीं अधिक होगी कि विशेष रूप से स्ट्रिंग का निर्माण कैसे किया जाए, इसलिए जो कुछ भी आपके लिए स्पष्ट है उसका उपयोग करें (मनुष्यों को पढ़ने के लिए कोड लिखें)।

उदाहरण के लिए:

public enum ValidTypes {

    PROPERTY1("123"),
    PROPERTY2("345");

    private final static String asString = calculateString();
    private final String value;

    private static String calculateString() {
        return // Do your work here.
    }

    ValidTypes(final String value) {
        this.value = value;
    }

    public static String toCommaSeparatedString() {
        return asString;
    }
}
2
Todd 10 अगस्त 2017, 22:27

यदि आपको इस स्थिर विधि को एक छोटी अवधि में हज़ारों बार कॉल करना है, तो आप प्रदर्शन के बारे में चिंता कर सकते हैं और आपको पहले यह जांचना चाहिए कि इसकी प्रदर्शन लागत है।
JVM रनटाइम पर कई अनुकूलन करता है।
तो अंत में आप बिना अतिरिक्त मूल्य के अधिक जटिल कोड लिख सकते हैं।


वैसे भी, आपको जो वास्तविक काम करना चाहिए वह String को toCommaSeperatedString द्वारा लौटाया गया है और उसी उदाहरण को वापस कर दिया गया है।
Enum स्थिर मान हैं। इसलिए उन्हें कैशिंग करना कोई समस्या नहीं है।

आप एक स्थिर प्रारंभकर्ता का उपयोग कर सकते हैं जो एक स्थिर स्ट्रिंग फ़ील्ड को महत्व देता है।
, वर्ण के बारे में, लूप के बाद इसे हटा दें।

public enum validTypes {

PROPERTY1("123"), PROPERTY2("456");

private static String valueSeparatedByComma;

static {
    StringBuilder commaSeperatedValidMsgTypes = new StringBuilder();
    for (validTypes msgType : validTypes.values()) {
        commaSeperatedValidMsgTypes.append(msgType.getValue());
        commaSeperatedValidMsgTypes.append(",");
    }

    commaSeperatedValidMsgTypes.deleteCharAt
    (commaSeperatedValidMsgTypes.length()-1);
    valueSeparatedByComma = commaSeperatedValidMsgTypes.toString();
}

public static String getvalueSeparatedByComma() {
    return valueSeparatedByComma;
}
2
davidxxx 10 अगस्त 2017, 22:34

मैं आमतौर पर एनम वर्ग पर ही एक स्थिर विधि जोड़ता हूं:

public enum Animal {
    CAT, DOG, LION;

    public static String possibleValues() {
        return Arrays.stream(Animal.values())
                .map(Enum::toString)
                .collect(Collectors.joining(","));
    }
}

इसलिए मैं इसे String possibleValues = Animal.possibleValues(); की तरह इस्तेमाल कर सकता हूं

2
Kent Munthe Caspersen 19 जून 2019, 16:01