Fatal编程技术网
  • java/
  • 将Java字符串从所有大写（用下划线分隔的单词）转换为CamelCase（无单词分隔符）的最简单方法是什么？

将Java字符串从所有大写（用下划线分隔的单词）转换为CamelCase（无单词分隔符）的最简单方法是什么？

java regex string

将Java字符串从所有大写（用下划线分隔的单词）转换为CamelCase（无单词分隔符）的最简单方法是什么？,java,regex,string,Java,Regex,String,标题几乎说明了一切。在Java中，我可以用什么最简单/最优雅的方式将字符串从格式“THIS\u是一个示例字符串”转换为格式“ThisIsAnExampleString”？我想至少有一种方法可以使用String.replaceAll（）和正则表达式来实现 我最初的想法是：在字符串前面加一个下划线（\uu），将整个字符串转换为小写，然后使用replaceAll将下划线前面的每个字符转换为大写 static String toCamelCase(String s){ String[] parts

标题几乎说明了一切。在Java中，我可以用什么最简单/最优雅的方式将字符串从格式
“THIS\u是一个示例字符串”
转换为格式“
ThisIsAnExampleString
”？我想至少有一种方法可以使用
String.replaceAll（）
和正则表达式来实现

我最初的想法是：在字符串前面加一个下划线（
\uu
），将整个字符串转换为小写，然后使用replaceAll将下划线前面的每个字符转换为大写

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
下面是一段代码片段，可能会有所帮助：

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
看看图书馆：

具体来说，大写（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);
}
具体来说，大写（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);
}
具体而言：

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

Maven工件是：org.modeshape:modeshape common:2.3.0.Final

在JBoss存储库上：

这是JAR文件：

您可以使用

具体而言：

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

Maven工件是：org.modeshape:modeshape common:2.3.0.Final

在JBoss存储库上：

下面是JAR文件：

不确定，但我认为通过逐字符执行，我可以使用更少的内存并获得可靠的性能。我也在做类似的事情，但是在后台线程的循环中，所以我现在正在尝试这个。我有一些使用String.split的经验，比预期的更贵。我正在安卓系统上工作，希望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();
  }

publicstaticstringtocamelcase（字符串值）{
StringBuilder sb=新的StringBuilder（）；
最终字符delimChar='u'；
布尔下限=假；
对于（int charInd=0；charInd
String.split代价高昂的一个提示是，它的输入是一个正则表达式（不是一个类似字符的String.indexOf），并且它返回一个数组（而不是说迭代器，因为循环一次只使用一个对象）。另外，像“AB_AB_AB_AB_AB_AB…”这样的情况会破坏任何大容量复制的效率，对于长字符串，使用的内存比输入字符串多一个数量级

然而，通过字符的循环没有规范的情况。因此，在我看来，不需要的正则表达式和数组的开销通常不太可取（这样就放弃了可能的大容量复制效率）。有兴趣听取意见/更正，谢谢。

不确定，但我认为我可以通过逐字符执行来使用更少的内存并获得可靠的性能。我也在做类似的事情，但是在后台线程的循环中，所以我现在正在尝试这个。我有一些使用String.split的经验，比预期的更贵。我正在安卓系统上工作，希望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();
  }

publicstaticstringtocamelcase（字符串值）{
StringBuilder sb=新的StringBuilder（）；
最终字符delimChar='u'；
布尔下限=假；
对于（int charInd=0；charInd
String.split代价高昂的一个提示是，它的输入是一个正则表达式（不是一个类似字符的String.indexOf），并且它返回一个数组（而不是说迭代器，因为循环一次只使用一个对象）。另外，像“AB_AB_AB_AB_AB_AB…”这样的情况会破坏任何大容量复制的效率，对于长字符串，使用的内存比输入字符串多一个数量级

然而，通过字符的循环没有规范的情况。因此，在我看来，不需要的正则表达式和数组的开销通常不太可取（这样就放弃了可能的大容量复制效率）。有兴趣听取意见/更正，谢谢。

另一个选择是使用Google Guava的
com.Google.common.base.CaseFormat

在下面的用法示例中留下注释：

CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "THIS_IS_AN_EXAMPLE_STRING");
另一种选择是使用谷歌番石榴的
com.Google.common.base.CaseFormat

在下面的用法示例中留下注释：

CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "THIS_IS_AN_EXAMPLE_STRING");
您也可以尝试以下方法：

 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;
    }
您也可以尝试以下方法：

 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;
    }
使用ApacheCommonsLang3lib非常简单

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"
使用ApacheCommonsLang3lib非常简单

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"
它将
枚举常量
转换为驼峰大小写。这将有助于任何人谁是寻找这样的功能

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 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);
}
解决这个问题的另一个办法可能如下

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);
}
使用流的Java1.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);
这是一些文本现在是thisIsSomeText

Java1.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);
这是一些文本现在是一些文本

执行时间：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;
}
执行时间：14毫秒

受保护的字符串到CAMELCASE（字符串i

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