जावा स्ट्रिंग को सभी कैप्स (अंडरस्कोर द्वारा अलग किए गए शब्द) से कैमलकेस (कोई शब्द सेपरेटर) में बदलने का सबसे सरल तरीका क्या है?

Question

शीर्षक सब कुछ बयां कर देता है। सबसे सरल / सबसे सुरुचिपूर्ण तरीका जो मैं परिवर्तित कर सकता हूं, जावा में, प्रारूप "THIS_IS_AN_EXAMPLE_STRING"से प्रारूप " ThisIsAnExampleString" के लिए एक स्ट्रिंग ? मुझे लगता है कि इसका उपयोग करने के लिए कम से कम एक तरीका होना चाहिए String.replaceAll()और एक रेगेक्स।

मेरे शुरुआती विचार हैं: स्ट्रिंग को अंडरस्कोर ( _) के साथ प्रीपेंड करें , पूरे स्ट्रिंग को लोअर केस में कनवर्ट करें, और उसके बाद अपने अपरकेस संस्करण के साथ अंडरस्कोर द्वारा पूर्ववर्ती प्रत्येक वर्ण को परिवर्तित करने के लिए रिप्लेसमेंट का उपयोग करें।

Comments

संपादक का नोट, 2015-03: उपरोक्त "प्रारंभिक विचार" सुपर गूंगा हैं। आप छह साल में सॉफ्टवेयर बनाने के बारे में बहुत कुछ सीखते हैं।

— मैट बॉल

वह क्षण जब आप पूछते हैं कि 'किस बेवकूफ ने यह लिखा था' और उस युवा, मूर्ख को खोजने के लिए स्रोत नियंत्रण में देखें। वहाँ किया गया था कि।

— सायं

@MattBall: मुझे शुरुआती विचार संस्करण पसंद हैं, इसके लिए एक पुस्तकालय की आवश्यकता नहीं है और बस एक स्ट्रिंग संयोजन और दो regex प्रतिस्थापन की आवश्यकता है।

— कोनराड हॉफनर

Answer 1

एक अन्य विकल्प Google Guava का उपयोग कर रहा है com.google.common.base.CaseFormat

जॉर्ज हॉकिन्स ने उपयोग के इस उदाहरण के साथ एक टिप्पणी छोड़ दी:

CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "THIS_IS_AN_EXAMPLE_STRING");

Comments

एक उदाहरण के लिए जॉर्ज हॉकिन्स [उपयोगकर्ता: 245602] द्वारा टिप्पणी का संदर्भ लें। stackoverflow.com/questions/1143951/…

— माइकल शेपर

मुझे एंड्रॉइड के लिए विकसित होने के साथ शुद्ध जावा उत्तर याद हैं।

— एलीक्स 11

यह उत्तर मेरे लिए सबसे उपयोगी है। मैं बहुत अच्छी तरह से अपना कोड लिख सकता था, लेकिन अगर किसी और के पास पहले से ही है, तो मैं निश्चित रूप से पहिया को सुदृढ़ नहीं करना चाहता।

— जेम्स डन

का संदर्भ लें stackoverflow.com/questions/10310321/... भी

— हर्टमट पी

@ CléssioMendes क्या आपने इसे github.com/google/guava/issues पर लाने का विचार किया है ?

— अर्नआउट एगेलन

Answer 2

Apache Commons lang लाइब्रेरी में WordUtils पर एक नज़र डालें :

विशेष रूप से, कैपिटलाइज़फुली (स्ट्रिंग str, char [] सीमांकक) विधि को कार्य करना चाहिए:

String blah = "LORD_OF_THE_RINGS";
assertEquals("LordOfTheRings", WordUtils.capitalizeFully(blah, new char[]{'_'}).replaceAll("_", ""));

हरी पट्टी!

Comments

नहीं साहब! हमें इन मौजूदा, पहले से काम कर रही उपयोगिताओं को फिर से लिखना चाहिए, क्योंकि हम उचित प्रोग्रामर हैं!

— स्कफमैन

शुक्रवार की दोपहर 16:42 है। मैं बाकी सबको इसे फिर से लिखने दूंगा, मैं एक बियर के लिए बाहर जा रहा हूँ /;)

— Dan Gravell

इस बिंदु पर अधिक, मेरे पास मेरे वर्तमान सेटअप के साथ उस विशेष पैकेज तक पहुंच भी नहीं है, और चूंकि मुझे वास्तव में कैपिटलाइज़लाइफ विधि से परे कुछ भी नहीं चाहिए, इसलिए मैं इसे स्वयं लिखकर कुछ भी नहीं खोता हूं।

— मैट बॉल

मैं आपके निर्णय का सम्मान करता हूं, यह शायद आपकी स्थिति में करने के लिए सही बात है। हालांकि, निम्नलिखित पर विचार करें: * आपकी टीम में किसी और ने निर्णय लिया है कि उन्हें पत्रों के मामले को स्वैप करने के लिए एक दिनचर्या की आवश्यकता है। वे इसे लागू करते हैं। अब आपके पास बनाए रखने के लिए ~ 20 लाइनें हैं। यदि आप पुस्तकालय का उपयोग करते हैं तो आपके पास ~ 2 होगा। और इकाई परीक्षण मत भूलना! * स्वीकृत उत्तर में एक नकारात्मक पहलू यह है कि विधि नाम यह नहीं बताता है कि कोड क्या करता है। कॉमन्स सामान की तरह एक अच्छी तरह से उपयोग की जाने वाली एपीआई में शायद ही कभी डाउनसाइड्स होते हैं। मुद्दा यह है कि रखरखाव सॉफ्टवेयर की सबसे बड़ी लागत है। आम तौर पर, पुन: उपयोग एक अच्छा विचार है।

— डैन ग्रेवेल

"इस विशेष पैकेज का उपयोग करने के लिए", repo1.maven.org/maven2/commons-lang/commons-lang/2.5/… को अपने वर्गपथ में छोड़ें । मावेन विरूपण साक्ष्य कॉमन्स-लैंग: कॉमन्स-लैंग: 2.5 है और यह मावेन सेंट्रल से आसानी से उपलब्ध है।

— हेंडी इरावन

Answer 3

static String toCamelCase(String s){
   String[] parts = s.split("_");
   String camelCaseString = "";
   for (String part : parts){
      camelCaseString = camelCaseString + toProperCase(part);
   }
   return camelCaseString;
}

static String toProperCase(String s) {
    return s.substring(0, 1).toUpperCase() +
               s.substring(1).toLowerCase();
}

नोट : आपको तर्क सत्यापन जोड़ने की आवश्यकता है।

Comments

अच्छा उत्तर है, लेकिन यह थोड़ा बेहतर होगा यदि विधि नाम ने इस तथ्य का वर्णन किया कि स्ट्रिंग विभाजित हो गई थी या वह तर्क बाहरी था और विधि को पाइप के रूप में संरेखित किया गया था, जैसे "THIS_IS_AN_EXAMPLE_STRING" .remuUnderscores () toCamelCase () यह। अधिक पुन: प्रयोज्य है।

— डैन ग्रेवेल

यह जरूरी बेहतर नहीं है (हालांकि हां, यह अधिक पुन: प्रयोज्य है)। जब नाम स्वरूपण सम्मेलनों की बात आती है, तो कैमलकेस अंडरस्कोर का उपयोग नहीं कर सकता है; सिक्के के रिवर्स साइड पर, ऐसे कन्वेंशन हैं जो अंडरस्कोर का उपयोग करते हैं। तो मेरे दिमाग में, यह सिर्फ एक प्रारूप से दूसरे प्रारूप में बदलने की एक विधि है।

— मैट बॉल

Google अमरूद पुस्तकालय में आम सम्मेलनों के बीच परिवर्तित करने के लिए एक अधिक सामान्य उपयोगिता है। इस मामले के लिए आप करेंगे String result = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "THIS_IS_AN_EXAMPLE_STRING");। Com.google.common.base.CaseFormat javadoc देखें ।

— जॉर्ज हॉकिन्स

तुर्की जैसे स्थानों में उपयोग किए जाने पर यह उत्तर समस्याओं में चलेगा ... यदि आपका कोड कई स्थानों पर उपयोग किया जा रहा है, तो toUpperCase (Locale) और toLowercase (Locale) का उपयोग करें .. जो कि डिफ़ॉल्ट लोकेल पर निर्भर नहीं हैं।

— vkraemer

@DanGravell: एक बार जब आप अंडरस्कोर हटा देते हैं, तो शब्दों को अलग करना संभव नहीं है।

— njzk2

Answer 4

Apache Commons Lang3 lib के साथ यह बहुत आसान है।

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.text.WordUtils;

public String getName(String text) {
  return StringUtils.remove(WordUtils.capitalizeFully(text, '_'), "_");
}

उदाहरण:

getName("SOME_CONSTANT");

देता है:

"SomeConstant"

Comments

चर नाम के मामले में, यह मान्य नहीं है क्योंकि नाम लोअरकेस से शुरू होना चाहिए।

— सेबी

Answer 5

public static void main(String[] args) {
    String start = "THIS_IS_A_TEST";
    StringBuffer sb = new StringBuffer();
    for (String s : start.split("_")) {
        sb.append(Character.toUpperCase(s.charAt(0)));
        if (s.length() > 1) {
            sb.append(s.substring(1, s.length()).toLowerCase());
        }
    }
    System.out.println(sb);
}

Comments

s.length परीक्षण आवश्यक नहीं है

— njzk2

Answer 6

यहाँ एक कोड स्निपेट है जो मदद कर सकता है:

String input = "ABC_DEF";
StringBuilder sb = new StringBuilder();
for( String oneString : input.toLowerCase().split("_") )
{
    sb.append( oneString.substring(0,1).toUpperCase() );
    sb.append( oneString.substring(1) );
}

// sb now holds your desired String

Comments

यह समाधान ALL_UPPER से ऊंट मामले के लिए उपयुक्त है। लेकिन कार्यक्रम में थोड़ा सा बदलाव भी मिक्सडेक या लोअरकेस (सांप का मामला) को संभाल सकता है। अगर मैंने अनुमति दी है तो मैंने एक संपादन का सुझाव दिया है।

— sud007

Answer 7

जावा 1.8 उदाहरण धाराओं का उपयोग करते हुए

String text = "THIS_IS_SOME_TEXT";

String bactrianCamel = Stream.of(text.split("[^a-zA-Z0-9]"))
        .map(v -> v.substring(0, 1).toUpperCase() + v.substring(1).toLowerCase())
        .collect(Collectors.joining());
String dromedaryCamel = bactrianCamel.toLowerCase().substring(0, 1) + bactrianCamel.substring(1); 

System.out.printf("%s is now %s%n", text, dromedaryCamel); 

THIS_IS_SOME_TEXT अब यह IsSomeText है

Comments

मुझे यह उत्तर पसंद है, लेकिन इसमें एक दोष है यदि इनपुट स्ट्रिंग पहले से ही ऊंट के मामले में है, तो यह पूरे इनपुट को कम करती है। उदाहरण के लिए abcDef abcdef हो जाता है।

— मृगदावगे

text.matches( "([a-z]+[a-zA-Z0-9]+)+" )ऊंट आवरण से पहले का उपयोग करने वाला एक परीक्षण संभवतः कम-आवरण मुद्दे के लिए एक उचित समाधान है।

— मृत्स्वद

Answer 8

निश्चित नहीं है, लेकिन मुझे लगता है कि मैं कम मेमोरी का उपयोग कर सकता हूं और इसे चार-चार कर कर भरोसेमंद प्रदर्शन प्राप्त कर सकता हूं। मैं कुछ ऐसा ही कर रहा था, लेकिन लूप में बैकग्राउंड थ्रेड्स में, इसलिए मैं अभी इसके लिए कोशिश कर रहा हूं। मुझे String.split के साथ कुछ अनुभव हुआ है और फिर महंगा होने की उम्मीद है। और मैं एंड्रॉइड पर काम कर रहा हूं और उम्मीद करता हूं कि GC hiccups एक इश्यू का अधिक उपयोग हो तो cpu का उपयोग करें।

  public static String toCamelCase(String value) {
    StringBuilder sb = new StringBuilder();

    final char delimChar = '_';
    boolean lower = false;
    for (int charInd = 0; charInd < value.length(); ++charInd) {
      final char valueChar = value.charAt(charInd);
      if (valueChar == delimChar) {
        lower = false;
      } else if (lower) {
        sb.append(Character.toLowerCase(valueChar));
      } else {
        sb.append(Character.toUpperCase(valueChar));
        lower = true;
      }
    }

    return sb.toString();
  }

एक संकेत है कि String.split महंगा है कि इसका इनपुट एक रेगेक्स है (String.indexOf की तरह नहीं) और यह एक सरणी लौटाता है (इसके बजाय एक पुनरावृत्त कहना है क्योंकि लूप केवल एक समय में एक चीज़ का उपयोग करता है)। "AB_AB_AB_AB_AB_AB ..." जैसे प्लस मामले किसी भी थोक प्रतिलिपि की दक्षता को तोड़ते हैं, और लंबे समय तक तार के लिए अधिक स्मृति के क्रम का उपयोग करते हैं फिर इनपुट स्ट्रिंग।

जबकि चर के माध्यम से लूपिंग में कोई विहित मामला नहीं है। तो मेरे लिए एक अनावश्यक रेगेक्स और सरणी का ओवरहेड आम तौर पर कम बेहतर लगता है (फिर संभव थोक प्रतिलिपि दक्षता देना)। राय / सुधार सुनने के इच्छुक हैं, धन्यवाद।

Answer 9

public String withChars(String inputa) {
    String input = inputa.toLowerCase();
    StringBuilder sb = new StringBuilder();
    final char delim = '_';
    char value;
    boolean capitalize = false;
    for (int i=0; i<input.length(); ++i) {
        value = input.charAt(i);
        if (value == delim) {
            capitalize = true;
        }
        else if (capitalize) {
            sb.append(Character.toUpperCase(value));
            capitalize = false;
        }
        else {
            sb.append(value);
        }
    }

    return sb.toString();
}

public String withRegex(String inputa) {
    String input = inputa.toLowerCase();
    String[] parts = input.split("_");
    StringBuilder sb = new StringBuilder();
    sb.append(parts[0]);
    for (int i=1; i<parts.length; ++i) {
        sb.append(parts[i].substring(0,1).toUpperCase());
        sb.append(parts[i].substring(1));
    }

    return sb.toString();
}

टाइम्स: मिलि सेकंड में।

Iterations = 1000
WithChars: start = 1379685214671 end = 1379685214683 diff = 12
WithRegex: start = 1379685214683 end = 1379685214712 diff = 29

Iterations = 1000
WithChars: start = 1379685217033 end = 1379685217045 diff = 12
WithRegex: start = 1379685217045 end = 1379685217077 diff = 32

Iterations = 1000
WithChars: start = 1379685218643 end = 1379685218654 diff = 11
WithRegex: start = 1379685218655 end = 1379685218684 diff = 29

Iterations = 1000000
WithChars: start = 1379685232767 end = 1379685232968 diff = 201
WithRegex: start = 1379685232968 end = 1379685233649 diff = 681

Iterations = 1000000
WithChars: start = 1379685237220 end = 1379685237419 diff = 199
WithRegex: start = 1379685237419 end = 1379685238088 diff = 669

Iterations = 1000000
WithChars: start = 1379685239690 end = 1379685239889 diff = 199
WithRegex: start = 1379685239890 end = 1379685240585 diff = 695

Iterations = 1000000000
WithChars: start = 1379685267523 end = 1379685397604 diff = 130081
WithRegex: start = 1379685397605 end = 1379685850582 diff = 452977

Comments

कूल, क्या यह इनपुट "THIS_IS_AN_EXAMPLE_STRING" के साथ है?

— लेओलेर

@leorleor इटरेशन = 1000000000 विथचर्स: स्टार्ट = 1387547394726 एंड = 1387547889896 diff = 495170 WithRegex: start = 1387547889897 एंड = 1387548944739 diff = 1054842

— Srisa

Answer 10

आप org.modeshape.common.text.Inflector का उपयोग कर सकते हैं ।

विशेष रूप से:

String camelCase(String lowerCaseAndUnderscoredWord,
    boolean uppercaseFirstLetter, char... delimiterChars) 

डिफ़ॉल्ट रूप से, यह विधि स्ट्रिंग्स को अपरकेंसेलकैसे में कनवर्ट करता है।

मावेन विरूपण साक्ष्य है: org.modeshape: modhape-common: 2.3.0.Final

JBoss भंडार पर: https://repository.jboss.org/nexus/content/repositories/relits

यहाँ JAR फ़ाइल है: https://repository.jboss.org/nexus/content/repositories/releases/org/modeshape/modeshape-common/2.3.0.Final/modeshape-common-2.3.0.Final.jar

Answer 11

आप इसे भी आजमा सकते हैं:

 public static String convertToNameCase(String s)
    {
        if (s != null)
        {
            StringBuilder b = new StringBuilder();
            String[] split = s.split(" ");
            for (String srt : split)
            {
                if (srt.length() > 0)
                {
                    b.append(srt.substring(0, 1).toUpperCase()).append(srt.substring(1).toLowerCase()).append(" ");
                }
            }
            return b.toString().trim();
        }
        return s;
    }

Answer 12

protected String toCamelCase(String input) {
    if (input == null) {
        return null;
    }

    if (input.length() == 0) {
        return "";
    }

    // lowercase the first character
    String camelCaseStr = input.substring(0, 1).toLowerCase();

    if (input.length() > 1) {
        boolean isStartOfWord = false;

        for (int i = 1; i < input.length(); i++) {
            char currChar = input.charAt(i);
            if (currChar == '_') {
                // new word. ignore underscore
                isStartOfWord = true;
            } else if (Character.isUpperCase(currChar)) {
                // capital letter. if start of word, keep it
                if (isStartOfWord) {
                    camelCaseStr += currChar;
                } else {
                    camelCaseStr += Character.toLowerCase(currChar);
                }
                isStartOfWord = false;
            } else {
                camelCaseStr += currChar;
                isStartOfWord = false;
            }
        }
    }

    return camelCaseStr;
}

Answer 13

public String CamelCase(String str)
{
    String CamelCase="";
    String parts[] = str.split("_");
    for(String part:parts)
    {
        String as=part.toLowerCase();
        int a=as.length();
        CamelCase = CamelCase + as.substring(0, 1).toUpperCase()+ as.substring(1,a);    
    }
    return CamelCase;
}

यह CamelCase में बदलने का सबसे सरल प्रोग्राम है। आशा है इससे आपकी मदद होगी..

Answer 14

यह Enum Constantकैमल केस में परिवर्तित हो जाएगा । यह ऐसे किसी भी व्यक्ति के लिए उपयोगी होगा जो इस तरह की मजेदारता की तलाश में है।

public enum TRANSLATE_LANGUAGES {
        ARABIC("ar"), BULGARIAN("bg"), CATALAN("ca"), CHINESE_SIMPLIFIED("zh-CN"), CHINESE_TRADITIONAL("zh-TW"), CZECH("cs"), DANISH("da"), DUTCH("nl"), ENGLISH("en"), ESTONIAN("et"), FINNISH("fi"), FRENCH(
                "fr"), GERMAN("de"), GREEK("el"), HAITIAN_CREOLE("ht"), HEBREW("he"), HINDI("hi"), HMONG_DAW("mww"), HUNGARIAN("hu"), INDONESIAN("id"), ITALIAN("it"), JAPANESE("ja"), KOREAN("ko"), LATVIAN(
                "lv"), LITHUANIAN("lt"), MALAY("ms"), NORWEGIAN("no"), PERSIAN("fa"), POLISH("pl"), PORTUGUESE("pt"), ROMANIAN("ro"), RUSSIAN("ru"), SLOVAK("sk"), SLOVENIAN("sl"), SPANISH("es"), SWEDISH(
                "sv"), THAI("th"), TURKISH("tr"), UKRAINIAN("uk"), URDU("ur"), VIETNAMESE("vi");

        private String code;

        TRANSLATE_LANGUAGES(String language) {
            this.code = language;
        }

        public String langCode() {
            return this.code;
        }

        public String toCamelCase(TRANSLATE_LANGUAGES lang) {
            String toString = lang.toString();
            if (toString.contains("_")) {
                String st = toUpperLowerCase(toString.split("_"));
            }

            return "";
        }

        private String toUpperLowerCase(String[] tempString) {
            StringBuilder builder = new StringBuilder();

            for (String temp : tempString) {

                String char1 = temp.substring(0, 1);
                String restString = temp.substring(1, temp.length()).toLowerCase();
                builder.append(char1).append(restString).append(" ");

            }

            return builder.toString();
        }
    }

Answer 15

इसका एक और समाधान इस प्रकार हो सकता है।

public static String toCamelCase(String str, String... separators) {
    String separatorsRegex = "\\".concat(org.apache.commons.lang3.StringUtils.join(separators, "|\\"));
    List splits = Arrays.asList(str.toLowerCase().split(separatorsRegex));
    String capitalizedString = (String)splits.stream().map(WordUtils::capitalize).reduce("", String::concat);
    return capitalizedString.substring(0, 1).toLowerCase() + capitalizedString.substring(1);
}

Answer 16

public static final String  UPPER_CAMEL = "initUp";
public static final String  LOWER_CAMEL = "initLow";

public String toCamel(String src, String separator, String format) {
    StringBuilder builder = new StringBuilder(src.toLowerCase());
    int len = builder.length();

    for (int idx = builder.indexOf(separator); idx > 0 && idx < len; idx = builder.indexOf(separator, idx)) {
        builder = builder.replace(idx, idx + 2, (String.valueOf(builder.charAt(idx + 1)).toUpperCase()));
    }

    switch (format) {
    case LOWER_CAMEL:
        builder.setCharAt(0, Character.toLowerCase(builder.charAt(0)));
        break;
    default:
        builder.setCharAt(0, Character.toUpperCase(builder.charAt(0)));
        break;
    }

    return builder.toString();

}

के रूप में मंगलाचरण

toCamel("THIS_IS_AN_EXAMPLE_STRING", "_", UPPER_CAMEL)

निष्पादन समय: 14 एमएस

Answer 17

एक साधारण स्निपेट:

 public static String camelCase(String in) {
    if (in == null || in.length() < 1) { return ""; } //validate in
    String out = "";
    for (String part : in.toLowerCase().split("_")) {
        if (part.length() < 1) { //validate length
            continue;
        }
        out += part.substring(0, 1).toUpperCase();
        if (part.length() > 1) { //validate length
            out += part.substring(1);
        }
    }
    return out;
}

Answer 18

कई तार के लिए जावा 8:

import com.google.common.base.CaseFormat;



String camelStrings = "YOUR_UPPER, YOUR_TURN, ALT_TAB";

List<String> camelList = Arrays.asList(camelStrings.split(","));
camelList.stream().forEach(i -> System.out.println(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, i) + ", "));

Comments

डुप्लीकेट उत्तर

— मार्क जेरोनिमस

Answer 19

    protected String toCamelCase(CaseFormat caseFormat, String... words){
        if (words.length  == 0){
          throw new IllegalArgumentException("Word list is empty!");
        }

        String firstWord = words[0];
        String [] restOfWords = Arrays.copyOfRange(words, 1, words.length);

        StringBuffer buffer = new StringBuffer();
        buffer.append(firstWord);
        Arrays.asList(restOfWords).stream().forEach(w->buffer.append("_"+ w.toUpperCase()));

        return CaseFormat.UPPER_UNDERSCORE.to(caseFormat, buffer.toString());

    }

Comments

CaseFormatमानक API नहीं है। यदि यह अमरूद है तो डुप्लिकेट उत्तर दें।

— मार्क जेरोनिमस