blocks|key|1501879|text|另一种选择是使用Google+Guava的com.google.common.base.CaseFormat|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1501880|George+Hawkins在下面的用法示例中留下了注释：|1501881|CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL,+"THIS_IS_AN_EXAMPLE_STRING");|code-block|syntax|javascript|1501882|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/245602/george-hawkins^0|L|X|0|0|E|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Another option is using Google Guava's <code>com.google.common.base.CaseFormat</code>

<a href="https://stackoverflow.com/users/245602/george-hawkins">George Hawkins</a> left a comment with this example of usage:

<pre><code>CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "THIS_IS_AN_EXAMPLE_STRING");
</code></pre>

blocks|key|1501736|text|看看WordUtils+in+the+Apache+Commons+lang库：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1501737|具体地说，capitalizeFully(String+str，char[]分隔符)方法应该完成以下工作：|1501738|String+blah+=+"LORD_OF_THE_RINGS";
assertEquals("LordOfTheRings",+WordUtils.capitalizeFully(blah,+'_').replaceAll("_",+""));|code-block|syntax|javascript|1501739|绿色条形图！|1501740|entityMap|0|LINK|mutability|MUTABLE|url|https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/WordUtils.html^0|2|10|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Take a look at <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/WordUtils.html" rel="noreferrer">WordUtils in the Apache Commons lang</a> library:
Specifically, the capitalizeFully(String str, char[] delimiters) method should do the job:
<pre><code>String blah = &quot;LORD_OF_THE_RINGS&quot;;
assertEquals(&quot;LordOfTheRings&quot;, WordUtils.capitalizeFully(blah, '_').replaceAll(&quot;_&quot;, &quot;&quot;));
</code></pre>
Green bar!

blocks|key|1501969|text|使用Apache+Commons+Lang3库是非常容易的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1501970|import+org.apache.commons.lang3.StringUtils;
import+org.apache.commons.lang3.text.WordUtils;

public+String+getName(String+text)+{
++return+StringUtils.remove(WordUtils.capitalizeFully(text,+'_'),+"_");
}|code-block|syntax|javascript|1501971|示例：|1501972|getName("SOME_CONSTANT");|1501973|提供：|1501974|"SomeConstant"|1501975|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

With Apache Commons Lang3 lib is it very easy.

<pre><code>import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.text.WordUtils;

public String getName(String text) {
 return StringUtils.remove(WordUtils.capitalizeFully(text, '_'), "_");
}
</code></pre>

Example:

<pre><code>getName("SOME_CONSTANT");
</code></pre>

Gives:

<pre><code>"SomeConstant"
</code></pre>

blocks|key|1501567|text|下面是一个可能会有帮助的代码片段：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1501568|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|code-block|syntax|javascript|1501569|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a code snippet which might help:

<pre><code>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
</code></pre>

blocks|key|1286922|text|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);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1286923|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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() &gt; 1) {
 sb.append(s.substring(1, s.length()).toLowerCase());
 }
 }
 System.out.println(sb);
}
</code></pre>

blocks|key|1502324|text|Apache+Commons项目现在确实有了CaseUtils类，该类有一个toCamelCase方法，它完全按照OP的要求执行操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1502325|+CaseUtils.toCamelCase("THIS_IS_AN_EXAMPLE_STRING",+true,+'_');|code-block|syntax|javascript|1502326|entityMap|0|LINK|mutability|MUTABLE|url|https://commons.apache.org/proper/commons-text/apidocs/org/apache/commons/text/CaseUtils.html|1|https://commons.apache.org/proper/commons-text/apidocs/org/apache/commons/text/CaseUtils.html#toCamelCase-java.lang.String-boolean-char...-^0|M|9|0|12|B|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

The Apache Commons project does now have the <a href="https://commons.apache.org/proper/commons-text/apidocs/org/apache/commons/text/CaseUtils.html" rel="nofollow noreferrer">CaseUtils</a> class, which has a <a href="https://commons.apache.org/proper/commons-text/apidocs/org/apache/commons/text/CaseUtils.html#toCamelCase-java.lang.String-boolean-char...-" rel="nofollow noreferrer">toCamelCase</a> method that does exactly as OP asked:
<pre><code> CaseUtils.toCamelCase(&quot;THIS_IS_AN_EXAMPLE_STRING&quot;, true, '_');
</code></pre>

blocks|key|1501820|text|不确定，但我认为我可以使用更少的内存，并通过逐个字符的方式获得可靠的性能。我正在做类似的事情，但是在后台线程中的循环中，所以我现在尝试这样做。我对String.split比预期的更贵有一些经验。我正在开发Android，我希望GC的问题会比cpu使用率更大。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1501821|++public+static+String+toCamelCase(String+value)+{
++++StringBuilder+sb+=+new+StringBuilder();

++++final+char+delimChar+=+'_';
++++boolean+lower+=+false;
++++for+(int+charInd+=+0;+charInd+<+value.length();+%2B%2BcharInd)+{
++++++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();
++}|code-block|syntax|javascript|1501822|String.split开销很大的一个提示是，它的输入是正则表达式(而不是像String.indexOf那样的字符)，并且它返回一个数组(而不是一个迭代器，因为循环一次只使用一个东西)。加上像"AB_AB_AB_AB_AB_AB...“这样的案例打破任何批量复制的效率，对于长字符串，使用比输入字符串多一个数量级的内存。|1501823|然而，循环通过字符没有规范的情况。因此，对我来说，不需要的正则表达式和数组的开销通常不太可取(然后放弃可能的批量复制效率)。有兴趣听取意见/更正，谢谢。|1501824|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Not sure, but I think I can use less memory and get dependable performance by doing it char-by-char. I was doing something similar, but in loops in background threads, so I am trying this for now. I've had some experience with String.split being more expensive then expected. And I am working on Android and expect GC hiccups to be more of an issue then cpu use.

<pre><code> public static String toCamelCase(String value) {
 StringBuilder sb = new StringBuilder();

 final char delimChar = '_';
 boolean lower = false;
 for (int charInd = 0; charInd &lt; 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();
 }
</code></pre>

A hint that String.split is expensive is that its input is a regex (not a char like String.indexOf) and it returns an array (instead of say an iterator because the loop only uses one things at a time). Plus cases like "AB_AB_AB_AB_AB_AB..." break the efficiency of any bulk copy, and for long strings use an order of magnitude more memory then the input string.

Whereas looping through chars has no canonical case. So to me the overhead of an unneeded regex and array seems generally less preferable (then giving up possible bulk copy efficiency). Interested to hear opinions / corrections, thanks.

blocks|key|1501916|text|您也可以尝试以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1501917|+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;
++++}|code-block|syntax|javascript|1501918|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can Try this also :

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

blocks|key|1287319|text|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%2B%2B)+{
++++++++++++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+%2B=+currChar;
++++++++++++++++}+else+{
++++++++++++++++++++camelCaseStr+%2B=+Character.toLowerCase(currChar);
++++++++++++++++}
++++++++++++++++isStartOfWord+=+false;
++++++++++++}+else+{
++++++++++++++++camelCaseStr+%2B=+currChar;
++++++++++++++++isStartOfWord+=+false;
++++++++++++}
++++++++}
++++}

++++return+camelCaseStr;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1287320|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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() &gt; 1) {
 boolean isStartOfWord = false;

 for (int i = 1; i &lt; 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;
}
</code></pre>

blocks|key|1502184|text|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+%2B+as.substring(0,+1).toUpperCase()%2B+as.substring(1,a);++++
++++}
++++return+CamelCase;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1502185|这是最简单的转换成CamelCase的程序。希望它能帮助你..|unstyled|1502186|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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;
}
</code></pre>

This is the Simplest Program to convert into CamelCase.
hope it Will Help You..

blocks|key|1287509|text|public+static+String+toCamelCase(String+value)+{
++++value+=+value.replace("_",+"+");
++++String[]+parts+=+value.split("+");
++++int+i+=+0;
++++String+camelCaseString+=+"";
++++for+(String+part+:+parts)+{
++++++++if+(part+!=+null+&&+!part.isEmpty())+{
++++++++++++if+(i+==+0)+{
++++++++++++++++camelCaseString+=+part.toLowerCase();
++++++++++++}+else+if+(i+>+0+&&+part.length()+>+1)+{
++++++++++++++++String+oldFirstChar+=+part.substring(0,+1);
++++++++++++++++camelCaseString+=+camelCaseString+%2B+part.replaceFirst(oldFirstChar,+oldFirstChar.toUpperCase());
++++++++++++}+else+{
++++++++++++++++camelCaseString+=+camelCaseString+%2B+part+%2B+"+";
++++++++++++}
++++++++++++i%2B%2B;
++++++++}
++++}
++++return+camelCaseString;
}

public+static+void+main(String[]+args)+{
++++String+string+=+"HI_tHiS_is_SomE+Statement";
++++System.out.println(toCamelCase(string));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1287510|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static String toCamelCase(String value) {
 value = value.replace(&quot;_&quot;, &quot; &quot;);
 String[] parts = value.split(&quot; &quot;);
 int i = 0;
 String camelCaseString = &quot;&quot;;
 for (String part : parts) {
 if (part != null &amp;&amp; !part.isEmpty()) {
 if (i == 0) {
 camelCaseString = part.toLowerCase();
 } else if (i &gt; 0 &amp;&amp; part.length() &gt; 1) {
 String oldFirstChar = part.substring(0, 1);
 camelCaseString = camelCaseString + part.replaceFirst(oldFirstChar, oldFirstChar.toUpperCase());
 } else {
 camelCaseString = camelCaseString + part + &quot; &quot;;
 }
 i++;
 }
 }
 return camelCaseString;
}

public static void main(String[] args) {
 String string = &quot;HI_tHiS_is_SomE Statement&quot;;
 System.out.println(toCamelCase(string));
}
</code></pre>

blocks|key|1287559|text|对不起我的5美分，我想java中的单词太多了))我只是想知道。为什么java中的regexp引擎不像在JS中那样熟悉lambdas+((|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1287560|不管怎么说。使用java+8%2B构造出现在我的脑海中：|1287561|Arrays.stream("THIS_IS_AN_EXAMPLE_STRING".split("_"))
++++.collect(StringBuilder::new,
++++++++(result,+w)+->+result
++++++++++++.append(w.substring(0,+1).toUpperCase())
++++++++++++.append(w.substring(1).toLowerCase()),
++++++++StringBuilder::append)
++++.toString())|code-block|syntax|javascript|1287562|如果你关心内存消耗，下面的代码关心它：|1287563|"THIS_IS_AN_EXAMPLE_STRING".chars().collect(StringBuilder::new,
++++(result,+c)+->+{
++++++++//+Detect+place+for+deal+with
++++++++if+(result.length()+>+0+&&+result.charAt(result.length()+-+1)+==+'_')+{
++++++++++++result.setCharAt(result.length()+-+1,
++++++++++++++++++++Character.toUpperCase((char)+c));
++++++++}+else+if+(result.length()+>+0)+{
++++++++++++result.append(Character.toLowerCase((char)+c));
++++++++}+else+{
++++++++++++result.append(Character.toUpperCase((char)+c));
++++++++}
++++},+StringBuilder::append).toString()|1287564|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Sorry for mine five cents, I think in java too many words))
I just wondering. Why is the regexp engine in java not so familiar with lambdas as in JS((
Anyway. With java 8+ construction appears in my mind:
<pre><code>Arrays.stream(&quot;THIS_IS_AN_EXAMPLE_STRING&quot;.split(&quot;_&quot;))
 .collect(StringBuilder::new,
 (result, w) -&gt; result
 .append(w.substring(0, 1).toUpperCase())
 .append(w.substring(1).toLowerCase()),
 StringBuilder::append)
 .toString())
</code></pre>
If you care about memory consumption, the below code care about it:
<pre><code>&quot;THIS_IS_AN_EXAMPLE_STRING&quot;.chars().collect(StringBuilder::new,
 (result, c) -&gt; {
 // Detect place for deal with
 if (result.length() &gt; 0 &amp;&amp; result.charAt(result.length() - 1) == '_') {
 result.setCharAt(result.length() - 1,
 Character.toUpperCase((char) c));
 } else if (result.length() &gt; 0) {
 result.append(Character.toLowerCase((char) c));
 } else {
 result.append(Character.toUpperCase((char) c));
 }
 }, StringBuilder::append).toString()
</code></pre>

blocks|key|1287177|text|它会将Enum+Constant转换为驼峰大小写。它将有助于任何正在寻找这样的功能性的人。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1287178|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();
++++++++}
++++}|code-block|syntax|javascript|1287179|entityMap^0|3|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

It will convert <code>Enum Constant</code> into Camel Case. It would be helpful for anyone who is looking for such funtionality. 

<pre><code>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();
 }
 }
</code></pre>

blocks|key|1287219|text|另一个解决方案可能如下所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1287220|public+static+String+toCamelCase(String+str,+String...+separators)+{
++++String+separatorsRegex+=+"\\".concat(org.apache.commons.lang3.StringUtils.join(separators,+"%7C\\"));
++++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()+%2B+capitalizedString.substring(1);
}|code-block|syntax|javascript|1287221|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

One more solution to this may be as follows.

<pre><code>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);
}
</code></pre>

blocks|key|1502119|text|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+%2B+2,+(String.valueOf(builder.charAt(idx+%2B+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();

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1502120|调用方式为|unstyled|1502121|toCamel("THIS_IS_AN_EXAMPLE_STRING",+"_",+UPPER_CAMEL)|1502122|执行时间:14ms|1502123|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>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 &gt; 0 &amp;&amp; idx &lt; 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();

}
</code></pre>

Invocation as 

<pre><code>toCamel("THIS_IS_AN_EXAMPLE_STRING", "_", UPPER_CAMEL)
</code></pre>

Execution Time: 14 ms

blocks|key|1502205|text|一个简单的代码片段：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1502206|+public+static+String+camelCase(String+in)+{
++++if+(in+==+null+%7C%7C+in.length()+<+1)+{+return+"";+}+//validate+in
++++String+out+=+"";
++++for+(String+part+:+in.toLowerCase().split("_"))+{
++++++++if+(part.length()+<+1)+{+//validate+length
++++++++++++continue;
++++++++}
++++++++out+%2B=+part.substring(0,+1).toUpperCase();
++++++++if+(part.length()+>+1)+{+//validate+length
++++++++++++out+%2B=+part.substring(1);
++++++++}
++++}
++++return+out;
}|code-block|syntax|javascript|1502207|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A simple snnipet:

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

blocks|key|1502263|text|++++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("_"%2B+w.toUpperCase()));

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

++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1502264|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> 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-&gt;buffer.append("_"+ w.toUpperCase()));

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

 }
</code></pre>

blocks|key|1502249|text|用于多个字符串的Java+8：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1502250|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)+%2B+",+"));|code-block|syntax|javascript|1502251|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Java 8 for multiple strings: 

<pre><code>import com.google.common.base.CaseFormat;



String camelStrings = "YOUR_UPPER, YOUR_TURN, ALT_TAB";

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

The title pretty much says it all. What's the simplest/most elegant way that I can convert, in Java, a string from the format <code>"THIS_IS_AN_EXAMPLE_STRING"</code> to the format "<code>ThisIsAnExampleString</code>"? I figure there must be at least one way to do it using <code>String.replaceAll()</code> and a regex.

My initial thoughts are: prepend the string with an underscore (<code>_</code>), convert the whole string to lower case, and then use replaceAll to convert every character preceded by an underscore with its uppercase version.

What is the simplest way to convert a Java string from all caps (words separated by underscores) to CamelCase (no word separators)?

Android

Java

标题几乎说明了一切。在Java语言中，将字符串从"THIS_IS_AN_EXAMPLE_STRING"格式转换为"ThisIsAnExampleString“格式的最简单/最优雅的方法是什么？我认为至少有一种使用String.replaceAll()和正则表达式的方法可以做到这一点。我最初的想法是:在字符串前面加上一个下划线(_)，将整个字符串转换为小写，然后使用replaceAll将每个带有下划

问将Java string从全部大写(由下划线分隔的单词)转换为CamelCase (没有单词分隔符)的最简单方法是什么？
EN

回答 18

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将Java string从全部大写(由下划线分隔的单词)转换为CamelCase (没有单词分隔符)的最简单方法是什么？EN

回答 18

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将Java string从全部大写(由下划线分隔的单词)转换为CamelCase (没有单词分隔符)的最简单方法是什么？
EN