【发布时间】：2010-11-08 08:07:15
【问题描述】：
是否有任何内置方法可以将字符串转换为 Title Case 格式？
【问题讨论】：
-
阅读此问题的每个人：请注意，此处投票最多的答案并不适用于所有语言。您需要一个支持 i18n 的库来正确命名，例如 ICU4J（参见 Daniel F 的回答）。
标签： java string title-case
【发布时间】：2010-11-08 08:07:15
【问题描述】：
Apache Commons StringUtils.capitalize() 或 Commons Text WordUtils.capitalize()
例如：WordUtils.capitalize("i am FINE") = "I Am FINE" 来自 WordUtils 文档
【讨论】：
-
WordUtils.capitalizeFully() 对我来说更好，因为它给出了：WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
-
只是一个小更新，WordUtils 已进入 Commons Text 并在 Commons Lang 中被弃用
-
春天也有
StringUtils.capitalise() -
@OrangeDog 你的意思是
capitalize()？ -
2021：Apache Commons 中的
WordUtils现在已弃用。 使用 StringUtils
Java 的 String 类中没有 capitalize() 或 titleCase() 方法。你有两个选择：
StringUtils.capitalize(null) = null
StringUtils.capitalize("") = ""
StringUtils.capitalize("cat") = "Cat"
StringUtils.capitalize("cAt") = "CAt"
StringUtils.capitalize("'cat'") = "'cat'"
- 编写（又一个）静态辅助方法 toTitleCase()
示例实现
public static String toTitleCase(String input) {
StringBuilder titleCase = new StringBuilder(input.length());
boolean nextTitleCase = true;
for (char c : input.toCharArray()) {
if (Character.isSpaceChar(c)) {
nextTitleCase = true;
} else if (nextTitleCase) {
c = Character.toTitleCase(c);
nextTitleCase = false;
}
titleCase.append(c);
}
return titleCase.toString();
}
测试用例
System.out.println(toTitleCase("string"));
System.out.println(toTitleCase("another string"));
System.out.println(toTitleCase("YET ANOTHER STRING"));
输出：
细绳 另一个字符串 另一个字符串【讨论】：
-
这是一个不错的小例程，但是对于字符串可能代表名称的更一般的情况它失败了。在这种情况下，大写也需要出现在撇号和连字符之后。例如。奥康纳和 J. Wilkes-Booth。当然，其他语言可能有额外的标题大小写规则。
-
...如果要包含它，是否需要整个字典查找才能确定当前单词是否为名称？对于任何一种方法来说，这似乎有点多。
-
这段代码几乎没问题，因为有些名字可以有介词，如 de、del、della、dei、da，如 Maria del Carmen、Maria da Silva、Maria della Salute 等。coderanch.com/t/35096/Programming/…
-
注意：为了避免在
StringBuilder中调整内部使用的char[]的大小，我建议使用new StringBuilder(input.length()) -
@sproketboy 我的想法是提供一种用于处理 Java 命名约定的实现，而不是用于处理表示名称等的任何类型的字符串。需要更多的努力来正确处理所有语言/区域差异以进行处理名字。
如果我可以提交我对解决方案的看法...
以下方法基于 dfa 发布的方法。它进行了以下重大更改（适合我当时需要的解决方案）：它将输入字符串中的所有字符强制为小写，除非它前面紧跟一个“可操作的分隔符”，在这种情况下，字符被强制转换为大写。
我的例程的一个主要限制是它假设“标题大小写”是为所有语言环境统一定义的，并且由我使用的相同大小写约定表示，因此在这方面它不如 dfa 的代码有用。
public static String toDisplayCase(String s) {
final String ACTIONABLE_DELIMITERS = " '-/"; // these cause the character following
// to be capitalized
StringBuilder sb = new StringBuilder();
boolean capNext = true;
for (char c : s.toCharArray()) {
c = (capNext)
? Character.toUpperCase(c)
: Character.toLowerCase(c);
sb.append(c);
capNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0); // explicit cast not needed
}
return sb.toString();
}
测试值
一个字符串
马丁奥马利
约翰·威尔克斯-布斯
还有一个字符串
输出
一个字符串
马丁·奥马利
约翰·威尔克斯-布斯
又一个字符串
【讨论】：
-
不适用于 lj 之类的连字，其大写字母为 LJ 但标题大写为 Lj。请改用
Character.toTitleCase。 -
@mihi：也不适用于其他专门规则，例如。姓氏，例如 McNamara 或 MacDonald。
-
但这些情况本来就无法修复。使用正确的大小写转换功能（根据 Unicode 规则，应该使用标题大写而不是大写）可以完成（而且很容易）。
-
不会（不会）这也会导致“她的”变成“她的”吗？
-
这是真的。这适用于名称字段，但正如您所指出的，不适用于一般散文。它甚至不适用于所有名称，尤其是 Vulcans（T'Pau 而不是 T'pau）。
使用来自 Apache Commons 的 WordUtils.capitalizeFully()。
WordUtils.capitalizeFully(null) = null
WordUtils.capitalizeFully("") = ""
WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
【讨论】：
-
不错的解决方案！谢谢！但这在 100% 的情况下都不起作用，因为它也大写例如此标题中的“a”：“这是一个标题”。见english.stackexchange.com/questions/14/…。你知道任何处理这个的图书馆吗？
你可以像这样使用 apache commons langs：
WordUtils.capitalizeFully("this is a text to be capitalize")
您可以在此处找到 java 文档： WordUtils.capitalizeFully java doc
如果你想删除世界之间的空格，你可以使用：
StringUtils.remove(WordUtils.capitalizeFully("this is a text to be capitalize")," ")
你可以找到 String 的 java 文档 StringUtils.remove java doc
希望对你有所帮助。
【讨论】：
这是基于@dfa 和@scottb 的回答的另一个观点，可以处理任何非字母/数字字符：
public final class TitleCase {
public static String toTitleCase(String input) {
StringBuilder titleCase = new StringBuilder(input.length());
boolean nextTitleCase = true;
for (char c : input.toLowerCase().toCharArray()) {
if (!Character.isLetterOrDigit(c)) {
nextTitleCase = true;
} else if (nextTitleCase) {
c = Character.toTitleCase(c);
nextTitleCase = false;
}
titleCase.append(c);
}
return titleCase.toString();
}
}
给定输入：
MARY ÄNN O'CONNEŽ-ŠUSLIK
输出是
玛丽·安·奥康内兹-舒斯利克
【讨论】：
如果你想根据最新的 Unicode 标准得到正确答案，你应该使用 icu4j。
UCharacter.toTitleCase(Locale.US, "hello world", null, 0);
请注意，这是区域设置敏感的。
【讨论】：
-
另见较新的 ICU4J API CaseMap：icu-project.org/apiref/icu4j/com/ibm/icu/text/…
-
在 Android API 级别 24 中也可用：developer.android.com/reference/android/icu/lang/…
-
我用以下内容对其进行了测试：“亚历山大和可怕的，可怕的，不好的，非常糟糕的一天，朱迪思·维斯特和雷·克鲁兹”我预期：“亚历山大和可怕的，可怕的，不好的, 非常糟糕的一天，朱迪思·维奥斯特和雷·克鲁兹”但实际结果是：“亚历山大和可怕的，可怕的，不好的，非常糟糕的一天，朱迪思·维奥斯特和雷·克鲁兹的”没有按预期工作。它只是将短语中的每个单词大写，与其他内置解决方案相同
-
@chomp 你想要一个基于人工智能的自然语言处理器。这超出了这里提到的大多数图书馆的能力，而且 - 我想说 - 超出了这个问题的范围。 “Title Case”意味着将所有内容都大写。
-
@DavidLavender 我同意这可能很难实现，但一件事是“标题案例”，另一件事是“完全大写”，也许这个名字可能会产生误导，或者至少在我的案子。 en.wikipedia.org/wiki/Title_case
这是我写的将snake_case转换为lowerCamelCase的东西，但可以根据要求轻松调整
private String convertToLowerCamel(String startingText)
{
String[] parts = startingText.split("_");
return parts[0].toLowerCase() + Arrays.stream(parts)
.skip(1)
.map(part -> part.substring(0, 1).toUpperCase() + part.substring(1).toLowerCase())
.collect(Collectors.joining());
}
【讨论】：
-
您的答案就像一个魅力，但是，该解决方案似乎无法处理单个单词序列，也许一个 if 条件就足够了。
使用 Spring 的 StringUtils:
org.springframework.util.StringUtils.capitalize(someText);
如果您已经在使用 Spring，这可以避免引入另一个框架。
【讨论】：
我知道这是较旧的方法，但没有简单的答案，我需要这种方法进行编码，所以我在此处添加，使用简单。
public static String toTitleCase(String input) {
input = input.toLowerCase();
char c = input.charAt(0);
String s = new String("" + c);
String f = s.toUpperCase();
return f + input.substring(1);
}
【讨论】：
使用此方法将字符串转换为标题大小写：
static String toTitleCase(String word) {
return Stream.of(word.split(" "))
.map(w -> w.toUpperCase().charAt(0)+ w.toLowerCase().substring(1))
.reduce((s, s2) -> s + " " + s2).orElse("");
}
【讨论】：
我遇到了这个问题，我搜索了它 然后我使用一些java关键字制作了自己的方法 只需将字符串变量作为参数传递并以正确的标题字符串形式获取输出。
public class Main
{
public static void main (String[]args)
{
String st = "pARVeEN sISHOsIYA";
String mainn = getTitleCase (st);
System.out.println (mainn);
}
public static String getTitleCase(String input)
{
StringBuilder titleCase = new StringBuilder (input.length());
boolean hadSpace = false;
for (char c:input.toCharArray ()){
if(Character.isSpaceChar(c)){
hadSpace = true;
titleCase.append (c);
continue;
}
if(hadSpace){
hadSpace = false;
c = Character.toUpperCase(c);
titleCase.append (c);
}else{
c = Character.toLowerCase(c);
titleCase.append (c);
}
}
String temp=titleCase.toString ();
StringBuilder titleCase1 = new StringBuilder (temp.length ());
int num=1;
for (char c:temp.toCharArray ())
{ if(num==1)
c = Character.toUpperCase(c);
titleCase1.append (c);
num=0;
}
return titleCase1.toString ();
}
}
【讨论】：
-
这里我没有在任何地方使用修剪方法，因为在我的情况下，我得到了正确的修剪字符串。
似乎没有一个答案在实际标题案例中格式化：“如何找到理想的工作”、“杀死一只知更鸟”等，所以我制定了自己的方法。最适合英语文本。
private final static Set<Character> TITLE_CASE_DELIMITERS = new HashSet<>();
static {
TITLE_CASE_DELIMITERS.add(' ');
TITLE_CASE_DELIMITERS.add('.');
TITLE_CASE_DELIMITERS.add(',');
TITLE_CASE_DELIMITERS.add(';');
TITLE_CASE_DELIMITERS.add('/');
TITLE_CASE_DELIMITERS.add('-');
TITLE_CASE_DELIMITERS.add('(');
TITLE_CASE_DELIMITERS.add(')');
}
private final static Set<String> TITLE_SMALLCASED_WORDS = new HashSet<>();
static {
TITLE_SMALLCASED_WORDS.add("a");
TITLE_SMALLCASED_WORDS.add("an");
TITLE_SMALLCASED_WORDS.add("the");
TITLE_SMALLCASED_WORDS.add("for");
TITLE_SMALLCASED_WORDS.add("in");
TITLE_SMALLCASED_WORDS.add("on");
TITLE_SMALLCASED_WORDS.add("of");
TITLE_SMALLCASED_WORDS.add("and");
TITLE_SMALLCASED_WORDS.add("but");
TITLE_SMALLCASED_WORDS.add("or");
TITLE_SMALLCASED_WORDS.add("nor");
TITLE_SMALLCASED_WORDS.add("to");
}
public static String toCapitalizedWord(String oneWord) {
if (oneWord.length() < 1) {
return oneWord.toUpperCase();
}
return "" + Character.toTitleCase(oneWord.charAt(0)) + oneWord.substring(1).toLowerCase();
}
public static String toTitledWord(String oneWord) {
if (TITLE_SMALLCASED_WORDS.contains(oneWord.toLowerCase())) {
return oneWord.toLowerCase();
}
return toCapitalizedWord(oneWord);
}
public static String toTitleCase(String str) {
StringBuilder result = new StringBuilder();
StringBuilder oneWord = new StringBuilder();
char previousDelimiter = 'x';
/* on start, always move to upper case */
for (char c : str.toCharArray()) {
if (TITLE_CASE_DELIMITERS.contains(c)) {
if (previousDelimiter == '-' || previousDelimiter == 'x') {
result.append(toCapitalizedWord(oneWord.toString()));
} else {
result.append(toTitledWord(oneWord.toString()));
}
oneWord.setLength(0);
result.append(c);
previousDelimiter = c;
} else {
oneWord.append(c);
}
}
if (previousDelimiter == '-' || previousDelimiter == 'x') {
result.append(toCapitalizedWord(oneWord.toString()));
} else {
result.append(toTitledWord(oneWord.toString()));
}
return result.toString();
}
public static void main(String[] args) {
System.out.println(toTitleCase("one year in paris"));
System.out.println(toTitleCase("How to Land Your Dream Job"));
}
【讨论】：
这是最简单的解决方案
static void title(String a,String b){
String ra = Character.toString(Character.toUpperCase(a.charAt(0)));
String rb = Character.toString(Character.toUpperCase(b.charAt(0)));
for(int i=1;i<a.length();i++){
ra+=a.charAt(i);
}
for(int i=1;i<b.length();i++){
rb+=b.charAt(i);
}
System.out.println(ra+" "+rb);
【讨论】：
你可以很好地使用
org.apache.commons.lang.WordUtils
或
案例格式
来自 Google 的 API。
【讨论】：
-
添加方法和示例会很有用。
-
CaseFormat 仅具有通常用于程序标识符的格式（UpperCamel、lower-hypen、UPPER_UNDERSCORE 等），并且仅支持 ASCII 文本。它不适用于转换为标题大小写。
我最近也遇到了这个问题，不幸的是，出现了很多以 Mc 和 Mac 开头的名字，我最终使用了一个 scottb 的代码版本，我改变了它来处理这些前缀，所以它就在这里，以防有人想使用它。
这仍然会遗漏一些边缘情况，但可能发生的最糟糕的事情是一个字母在应该大写时会变成小写。
/**
* Get a nicely formatted representation of the name.
* Don't send this the whole name at once, instead send it the components.<br>
* For example: andrew macnamara would be returned as:<br>
* Andrew Macnamara if processed as a single string<br>
* Andrew MacNamara if processed as 2 strings.
* @param name
* @return correctly formatted name
*/
public static String getNameTitleCase (String name) {
final String ACTIONABLE_DELIMITERS = " '-/";
StringBuilder sb = new StringBuilder();
if (name !=null && !name.isEmpty()){
boolean capitaliseNext = true;
for (char c : name.toCharArray()) {
c = (capitaliseNext)?Character.toUpperCase(c):Character.toLowerCase(c);
sb.append(c);
capitaliseNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0);
}
name = sb.toString();
if (name.startsWith("Mc") && name.length() > 2 ) {
char c = name.charAt(2);
if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
sb = new StringBuilder();
sb.append (name.substring(0,2));
sb.append (name.substring(2,3).toUpperCase());
sb.append (name.substring(3));
name=sb.toString();
}
} else if (name.startsWith("Mac") && name.length() > 3) {
char c = name.charAt(3);
if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
sb = new StringBuilder();
sb.append (name.substring(0,3));
sb.append (name.substring(3,4).toUpperCase());
sb.append (name.substring(4));
name=sb.toString();
}
}
}
return name;
}
【讨论】：
转换为正确的标题大小写：
String s= "ThiS iS SomE Text";
String[] arr = s.split(" ");
s = "";
for (String s1 : arr) {
s += WordUtils.capitalize(s1.toLowerCase()) + " ";
}
s = s.substring(0, s.length() - 1);
结果：“这是一些文本”
【讨论】：
此转换器将包含驼峰式、空格、数字和其他字符的任何字符串转换为经过净化的标题大小写。
/**
* Convert a string to title case in java (with tests).
*
* @author Sudipto Chandra
*/
public abstract class TitleCase {
/**
* Returns the character type. <br>
* <br>
* Digit = 2 <br>
* Lower case alphabet = 0 <br>
* Uppercase case alphabet = 1 <br>
* All else = -1.
*
* @param ch
* @return
*/
private static int getCharType(char ch) {
if (Character.isLowerCase(ch)) {
return 0;
} else if (Character.isUpperCase(ch)) {
return 1;
} else if (Character.isDigit(ch)) {
return 2;
}
return -1;
}
/**
* Converts any given string in camel or snake case to title case.
* <br>
* It uses the method getCharType and ignore any character that falls in
* negative character type category. It separates two alphabets of not-equal
* cases with a space. It accepts numbers and append it to the currently
* running group, and puts a space at the end.
* <br>
* If the result is empty after the operations, original string is returned.
*
* @param text the text to be converted.
* @return a title cased string
*/
public static String titleCase(String text) {
if (text == null || text.length() == 0) {
return text;
}
char[] str = text.toCharArray();
StringBuilder sb = new StringBuilder();
boolean capRepeated = false;
for (int i = 0, prev = -1, next; i < str.length; ++i, prev = next) {
next = getCharType(str[i]);
// trace consecutive capital cases
if (prev == 1 && next == 1) {
capRepeated = true;
} else if (next != 0) {
capRepeated = false;
}
// next is ignorable
if (next == -1) {
// System.out.printf("case 0, %d %d %s\n", prev, next, sb.toString());
continue; // does not append anything
}
// prev and next are of same type
if (prev == next) {
sb.append(str[i]);
// System.out.printf("case 1, %d %d %s\n", prev, next, sb.toString());
continue;
}
// next is not an alphabet
if (next == 2) {
sb.append(str[i]);
// System.out.printf("case 2, %d %d %s\n", prev, next, sb.toString());
continue;
}
// next is an alphabet, prev was not +
// next is uppercase and prev was lowercase
if (prev == -1 || prev == 2 || prev == 0) {
if (sb.length() != 0) {
sb.append(' ');
}
sb.append(Character.toUpperCase(str[i]));
// System.out.printf("case 3, %d %d %s\n", prev, next, sb.toString());
continue;
}
// next is lowercase and prev was uppercase
if (prev == 1) {
if (capRepeated) {
sb.insert(sb.length() - 1, ' ');
capRepeated = false;
}
sb.append(str[i]);
// System.out.printf("case 4, %d %d %s\n", prev, next, sb.toString());
}
}
String output = sb.toString().trim();
output = (output.length() == 0) ? text : output;
//return output;
// Capitalize all words (Optional)
String[] result = output.split(" ");
for (int i = 0; i < result.length; ++i) {
result[i] = result[i].charAt(0) + result[i].substring(1).toLowerCase();
}
output = String.join(" ", result);
return output;
}
/**
* Test method for the titleCase() function.
*/
public static void testTitleCase() {
System.out.println("--------------- Title Case Tests --------------------");
String[][] samples = {
{null, null},
{"", ""},
{"a", "A"},
{"aa", "Aa"},
{"aaa", "Aaa"},
{"aC", "A C"},
{"AC", "Ac"},
{"aCa", "A Ca"},
{"ACa", "A Ca"},
{"aCamel", "A Camel"},
{"anCamel", "An Camel"},
{"CamelCase", "Camel Case"},
{"camelCase", "Camel Case"},
{"snake_case", "Snake Case"},
{"toCamelCaseString", "To Camel Case String"},
{"toCAMELCase", "To Camel Case"},
{"_under_the_scoreCamelWith_", "Under The Score Camel With"},
{"ABDTest", "Abd Test"},
{"title123Case", "Title123 Case"},
{"expect11", "Expect11"},
{"all0verMe3", "All0 Ver Me3"},
{"___", "___"},
{"__a__", "A"},
{"_A_b_c____aa", "A B C Aa"},
{"_get$It132done", "Get It132 Done"},
{"_122_", "122"},
{"_no112", "No112"},
{"Case-13title", "Case13 Title"},
{"-no-allow-", "No Allow"},
{"_paren-_-allow--not!", "Paren Allow Not"},
{"Other.Allow.--False?", "Other Allow False"},
{"$39$ldl%LK3$lk_389$klnsl-32489 3 42034 ", "39 Ldl Lk3 Lk389 Klnsl32489342034"},
{"tHis will BE MY EXAMple", "T His Will Be My Exa Mple"},
{"stripEvery.damn-paren- -_now", "Strip Every Damn Paren Now"},
{"getMe", "Get Me"},
{"whatSthePoint", "What Sthe Point"},
{"n0pe_aLoud", "N0 Pe A Loud"},
{"canHave SpacesThere", "Can Have Spaces There"},
{" why_underScore exists ", "Why Under Score Exists"},
{"small-to-be-seen", "Small To Be Seen"},
{"toCAMELCase", "To Camel Case"},
{"_under_the_scoreCamelWith_", "Under The Score Camel With"},
{"last one onTheList", "Last One On The List"}
};
int pass = 0;
for (String[] inp : samples) {
String out = titleCase(inp[0]);
//String out = WordUtils.capitalizeFully(inp[0]);
System.out.printf("TEST '%s'\nWANTS '%s'\nFOUND '%s'\n", inp[0], inp[1], out);
boolean passed = (out == null ? inp[1] == null : out.equals(inp[1]));
pass += passed ? 1 : 0;
System.out.println(passed ? "-- PASS --" : "!! FAIL !!");
System.out.println();
}
System.out.printf("\n%d Passed, %d Failed.\n", pass, samples.length - pass);
}
public static void main(String[] args) {
// run tests
testTitleCase();
}
}
这里有一些输入：
aCamel
TitleCase
snake_case
fromCamelCASEString
ABCTest
expect11
_paren-_-allow--not!
why_underScore exists
last one onTheList
还有我的输出：
A Camel
Title Case
Snake Case
From Camel Case String
Abc Test
Expect11
Paren Allow Not
Why Under Score Exists
Last One On The List
【讨论】：
这应该可行：
String str="i like pancakes";
String arr[]=str.split(" ");
String strNew="";
for(String str1:arr)
{
Character oldchar=str1.charAt(0);
Character newchar=Character.toUpperCase(str1.charAt(0));
strNew=strNew+str1.replace(oldchar,newchar)+" ";
}
System.out.println(strNew);
【讨论】：
-
这不是一个有效的答案，因为 OP 要求提供 builtin 功能。另请参阅解决其背后隐藏复杂性的评论，即 i18n。
将任何字符串转换为标题大小写的最简单方法是使用谷歌包 org.apache.commons.lang.WordUtils
System.out.println(WordUtils.capitalizeFully("tHis will BE MY EXAMple"));
结果会这样
这就是我的榜样
我不知道为什么它被命名为“capitalizeFully”，实际上这个函数并没有做一个完整的资本结果，但无论如何，这就是我们需要的工具。
【讨论】：
-
它被命名为
capitalizeFully，因为它将每个单词都大写，包括那些在标题中应该小写的单词。 grammar.about.com/od/tz/g/Title-Case.htm -
Apache Commons 不归 Google 所有。它由 Apache 软件基金会维护。 commons.apache.org
对不起，我是初学者，所以我的编码习惯很糟糕！
public class TitleCase {
String title(String sent)
{
sent =sent.trim();
sent = sent.toLowerCase();
String[] str1=new String[sent.length()];
for(int k=0;k<=str1.length-1;k++){
str1[k]=sent.charAt(k)+"";
}
for(int i=0;i<=sent.length()-1;i++){
if(i==0){
String s= sent.charAt(i)+"";
str1[i]=s.toUpperCase();
}
if(str1[i].equals(" ")){
String s= sent.charAt(i+1)+"";
str1[i+1]=s.toUpperCase();
}
System.out.print(str1[i]);
}
return "";
}
public static void main(String[] args) {
TitleCase a = new TitleCase();
System.out.println(a.title(" enter your Statement!"));
}
}
【讨论】：