将 Java 字符串从所有大写(单词由下划线分隔)转换为 CamelCase (没有单词分隔符)的最简单方法是什么？

标题差不多说明了一切。在 Java 中，将字符串从格式 "THIS_IS_AN_EXAMPLE_STRING"转换为格式“ ThisIsAnExampleString”的最简单/最优雅的方法是什么？我认为至少有一种方法可以使用 String.replaceAll()和正则表达式来完成。

我最初的想法是: 在字符串前面加一个下划线(_) ，将整个字符串转换为小写，然后使用 replaceAll 将前面加一个下划线的每个字符转换为大写形式。

256905 次浏览
小开 
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();
}

注意 : 您需要添加参数验证。

小开

下面的代码片段可能会有所帮助:

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
小开

看看 Apache Commons lang 中的 WordUtils库:

具体来说，CapitalizeFull (String str，char []分隔符)方法应该完成这项工作:

String blah = "LORD_OF_THE_RINGS";
assertEquals("LordOfTheRings", WordUtils.capitalizeFully(blah, '_').replaceAll("_", ""));

绿条！

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

你可以使用 Org.modeshape.common.text。

具体来说:

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

默认情况下，此方法将字符串转换为 UpperCamelCase。

玛文的藏物是: Modeshape: modeshape-common: 2.3.0. Final

关于 JBoss 存储库: https://repository.jboss.org/nexus/content/repositories/releases

这是 JAR 文件: https://repository.jboss.org/nexus/content/repositories/releases/org/modeshape/modeshape-common/2.3.0.Final/modeshape-common-2.3.0.Final.jar

小开

不确定，但我认为我可以使用更少的内存，并通过逐字符执行它来获得可靠的性能。我正在做类似的事情，但在后台线程的循环，所以我现在正在尝试这一点。我有一些经验，与字符串。分裂比预期的更昂贵。我正在研究 Android 系统，希望 GC 的问题比 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.indexOf 那样的字符) ，并且它返回一个数组(而不是迭代器，因为循环一次只使用一个元素)。另外，像“ AB _ AB _ AB _ AB _ AB _ AB...”这样的情况会打破任何批量复制的效率，对于长字符串，数量级比输入字符串使用更多的内存。

而循环遍历字符没有规范情况。因此，对我来说，一个不需要的正则表达式和数组的开销似乎通常不太可取(然后放弃可能的大容量复制效率)。有兴趣听取意见/纠正，谢谢。

小开
最佳答案

另一个选择是使用谷歌番石榴的 com.google.common.base.CaseFormat

乔治 · 霍金斯(George Hawkins)留下了这样一个用法的例子:

CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "THIS_IS_AN_EXAMPLE_STRING");
小开 
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
小开

你也可以试试这个:

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

使用 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"
小开

它将把 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();
}
}
小开

另一个解决方案可能如下所示。

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

使用 Streams 的 Java 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 现在是 < em > THIS IsSome 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 + 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毫秒

小开 
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;
}
小开 
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 的最简单的程序。 希望能帮到你。

小开

一个简单的笑话:

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

Java8用于多个字符串:

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) + ", "));
小开 
    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());


}
小开

Apache Commons 项目现在有了 CaseUtils类，它有一个 到 CamelCase方法，完全按 OP 要求执行:

 CaseUtils.toCamelCase("THIS_IS_AN_EXAMPLE_STRING", true, '_');
小开 
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 + part.replaceFirst(oldFirstChar, oldFirstChar.toUpperCase());
} else {
camelCaseString = camelCaseString + part + " ";
}
i++;
}
}
return camelCaseString;
}


public static void main(String[] args) {
String string = "HI_tHiS_is_SomE Statement";
System.out.println(toCamelCase(string));
}
小开

对不起，我的五分钱，我认为在爪哇太多的话)) 我只是想知道，为什么 java 中的 regexp 引擎不像 JS ((

无论如何，java 8 + 的结构出现在我的脑海中:

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())

如果您关心内存消耗，那么下面的代码关心它:

"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()

提交答案