Java 如何将字符串中每个单词的第一个字母大写？

我有一个字符串：“hello good old world”，我希望每个单词的第一个字母都大写，而不是使用.toUpperCase（）的整个字符串。是否有一个现有的java助手来执行此任务？

我不知道是否有函数，但如果没有函数，此函数将执行此任务：

String s = "here are a bunch of words";

final StringBuilder result = new StringBuilder(s.length());
String[] words = s.split("\\s");
for(int i=0,l=words.length;i<l;++i) {
  if(i>0) result.append(" ");      
  result.append(Character.toUpperCase(words[i].charAt(0)))
        .append(words[i].substring(1));

}

String s=“这里有一堆单词”；
最终StringBuilder结果=新StringBuilder（s.length（））；
字符串[]字=s.split（\\s”）；
对于（inti=0，l=words.length；i0）result.append（“”）；
result.append（Character.toUpperCase（words[i].charAt（0）））
.append（字[i].子串（1））；
}

看看ACL

---

你们也可以去图书馆看看。它有一大堆很酷的东西。

公共字符串大写词（字符串行）
public String UpperCaseWords(String line)
{
    line = line.trim().toLowerCase();
    String data[] = line.split("\\s");
    line = "";
    for(int i =0;i< data.length;i++)
    {
        if(data[i].length()>1)
            line = line + data[i].substring(0,1).toUpperCase()+data[i].substring(1)+" ";
        else
            line = line + data[i].toUpperCase();
    }
    return line.trim();
}

{
line=line.trim（）.toLowerCase（）；
字符串数据[]=行分割（\\s”）；
第“”行；
for（int i=0；i1）
line=line+data[i].子字符串（0,1）.toUpperCase（）+数据[i].子字符串（1）+'；
其他的
line=line+data[i].toUpperCase（）；
}
返回线.trim（）；
}

导入java.util.Scanner；
公共类CapitalIzeOneString{
公共静态void main（字符串[]args）
{
扫描仪扫描=新扫描仪（System.in）；
System.out.print（“请输入您的word=”）；
String str=scan.nextLine（）；
印刷体大写（str）；
}//结束main（）
静态无效打印大写（字符串str）{
//使用
//每个单词的第一个大写字母。
char ch；//str中的一个字符。
char prevCh；//字符串中ch前面的字符。
int i；//str中的一个位置，从0到str.length（）-1。
prevCh='..'；//使用任何非字母字符为循环加素数。
对于（i=0；i

这里有一个非常简单、紧凑的解决方案。str包含您想要对其执行的任何操作的变量（大写）

StringBuilder b = new StringBuilder(str);
int i = 0;
do {
  b.replace(i, i + 1, b.substring(i,i + 1).toUpperCase());
  i =  b.indexOf(" ", i) + 1;
} while (i > 0 && i < b.length());

System.out.println(b.toString());

StringBuilder b=新的StringBuilder（str）；
int i=0；
做{
b、 替换（i，i+1，b.子字符串（i，i+1）.toUpperCase（））；
i=b.indexOf（“，i）+1；
}而（i>0&&i

最好使用StringBuilder，因为字符串是不可变的，并且为每个单词生成新字符串的效率很低。

以下是代码

    String source = "hello good old world";
    StringBuffer res = new StringBuffer();

    String[] strArr = source.split(" ");
    for (String str : strArr) {
        char[] stringArray = str.trim().toCharArray();
        stringArray[0] = Character.toUpperCase(stringArray[0]);
        str = new String(stringArray);

        res.append(str).append(" ");
    }

    System.out.print("Result: " + res.toString().trim());

public class WordChangeInCapital{
公共静态void main（字符串[]args）
{
String s=“这是字符串示例”；
系统输出打印项次；
//这是输入数据。
//此示例适用于每个单词必须以大写字母开头的字符串
StringBuffer sb=新的StringBuffer；
int i=0；
做{
b、 替换（i，i+1，sb.子字符串（i，i+1）.toUpperCase（））；
i=b.indexOf（“，i）+1；
}而（i>0&&i
package com.raj.samplestring；
/**
*@作者gnagara
*/
公共类样本字符串{
/**
*@param args
*/
公共静态void main（字符串[]args）{
字符串[]字符串数组；
String givenString=“ramu是个好孩子”；
stringArray=givenString.split（“”）；
对于（int i=0；i尝试比将字符串拆分为多个字符串更高效的内存，并使用Darshana斯里兰卡所示的策略。此外，处理单词之间的所有空白，而不仅仅是“”字符

public static String UppercaseFirstLetters(String str) 
{
    boolean prevWasWhiteSp = true;
    char[] chars = str.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        if (Character.isLetter(chars[i])) {
            if (prevWasWhiteSp) {
                chars[i] = Character.toUpperCase(chars[i]);    
            }
            prevWasWhiteSp = false;
        } else {
            prevWasWhiteSp = Character.isWhitespace(chars[i]);
        }
    }
    return new String(chars);
}

公共静态字符串大写字母（String str）
{
布尔值p=true；
char[]chars=str.toCharArray（）；
for（int i=0；i

输出：

这是第一个单词大写测试

这是第一个单词大写测试。
这里有一个简单的解决方案：

public class CapitalFirstLetters {

 public static void main(String[] args) {
    String word = "it's java, baby!";
    String[] wordSplit;
    String wordCapital = "";
    wordSplit = word.split(" ");
    for (int i = 0; i < wordSplit.length; i++) {
        wordCapital = wordSplit[i].substring(0, 1).toUpperCase() + wordSplit[i].substring(1) + " ";
    }
    System.out.println(wordCapital);
 }}

public class capital firstletters{
公共静态void main（字符串[]args）{
String word=“这是java，宝贝！”；
字符串[]字拆分；
字符串wordCapital=“”；
wordSplit=word.split（“”）；
for（int i=0；i
使用正则表达式要简单得多：

Pattern spaces=Pattern.compile("\\s+[a-z]");       
Matcher m=spaces.matcher(word);    
StringBuilder capitalWordBuilder=new StringBuilder(word.substring(0,1).toUpperCase());
int prevStart=1;
        while(m.find()) {
                capitalWordBuilder.append(word.substring(prevStart,m.end()-1));
                capitalWordBuilder.append(word.substring(m.end()-1,m.end()).toUpperCase());
                prevStart=m.end();
        }   
        capitalWordBuilder.append(word.substring(prevStart,word.length()));

输入输出：“这个句子有奇怪的大写字母”

这句话有奇怪的大写字母
String s=“java是一种面向对象的编程语言。”；
    String s = "java is an object oriented programming language.";      
    final StringBuilder result = new StringBuilder(s.length());    
    String words[] = s.split("\\ "); // space found then split it  
    for (int i = 0; i < words.length; i++) 
         {
    if (i > 0){
    result.append(" ");
    }   
    result.append(Character.toUpperCase(words[i].charAt(0))).append(
                words[i].substring(1));   
    }  
    System.out.println(result);  

最终StringBuilder结果=新StringBuilder（s.length（））；
字符串字[]=s.split（\\”；//找到空格，然后将其拆分
for（int i=0；i0）{
结果。追加（“”）；
}   
result.append（Character.toUpperCase（words[i].charAt（0））.append(
字[i].子串（1））；
}  
系统输出打印项次（结果）；

输出：Java是一种面向对象的编程语言。
在阅读了上面的几个答案后，我的代码

/**
 * Returns the given underscored_word_group as a Human Readable Word Group.
 * (Underscores are replaced by spaces and capitalized following words.)
 * 
 * @param pWord
 *            String to be made more readable
 * @return Human-readable string
 */
public static String humanize2(String pWord)
{
    StringBuilder sb = new StringBuilder();
    String[] words = pWord.replaceAll("_", " ").split("\\s");
    for (int i = 0; i < words.length; i++)
    {
        if (i > 0)
            sb.append(" ");
        if (words[i].length() > 0)
        {
            sb.append(Character.toUpperCase(words[i].charAt(0)));
            if (words[i].length() > 1)
            {
                sb.append(words[i].substring(1));
            }
        }
    }
    return sb.toString();
}

/**
*将给定的带下划线的单词组作为人类可读的单词组返回。
*（下划线替换为空格，并在单词后面大写。）
* 
*@param pWord
*使字符串更可读
*@return人类可读字符串
*/
公共静态字符串（字符串pWord）
{
StringBuilder sb=新的StringBuilder（）；
斯特里
import org.apache.commons.lang.WordUtils;

public class CapitalizeFirstLetterInString {
    public static void main(String[] args) {
        // only the first letter of each word is capitalized.
        String wordStr = WordUtils.capitalize("this is first WORD capital test.");
        //Capitalize method capitalizes only first character of a String
        System.out.println("wordStr= " + wordStr);

        wordStr = WordUtils.capitalizeFully("this is first WORD capital test.");
        // This method capitalizes first character of a String and make rest of the characters lowercase
        System.out.println("wordStr = " + wordStr );
    }
}

public class CapitalFirstLetters {

 public static void main(String[] args) {
    String word = "it's java, baby!";
    String[] wordSplit;
    String wordCapital = "";
    wordSplit = word.split(" ");
    for (int i = 0; i < wordSplit.length; i++) {
        wordCapital = wordSplit[i].substring(0, 1).toUpperCase() + wordSplit[i].substring(1) + " ";
    }
    System.out.println(wordCapital);
 }}

sString = sString.toLowerCase();
sString = Character.toString(sString.charAt(0)).toUpperCase()+sString.substring(1);

Pattern spaces=Pattern.compile("\\s+[a-z]");       
Matcher m=spaces.matcher(word);    
StringBuilder capitalWordBuilder=new StringBuilder(word.substring(0,1).toUpperCase());
int prevStart=1;
        while(m.find()) {
                capitalWordBuilder.append(word.substring(prevStart,m.end()-1));
                capitalWordBuilder.append(word.substring(m.end()-1,m.end()).toUpperCase());
                prevStart=m.end();
        }   
        capitalWordBuilder.append(word.substring(prevStart,word.length()));

    String s = "java is an object oriented programming language.";      
    final StringBuilder result = new StringBuilder(s.length());    
    String words[] = s.split("\\ "); // space found then split it  
    for (int i = 0; i < words.length; i++) 
         {
    if (i > 0){
    result.append(" ");
    }   
    result.append(Character.toUpperCase(words[i].charAt(0))).append(
                words[i].substring(1));   
    }  
    System.out.println(result);  

/**
 * Returns the given underscored_word_group as a Human Readable Word Group.
 * (Underscores are replaced by spaces and capitalized following words.)
 * 
 * @param pWord
 *            String to be made more readable
 * @return Human-readable string
 */
public static String humanize2(String pWord)
{
    StringBuilder sb = new StringBuilder();
    String[] words = pWord.replaceAll("_", " ").split("\\s");
    for (int i = 0; i < words.length; i++)
    {
        if (i > 0)
            sb.append(" ");
        if (words[i].length() > 0)
        {
            sb.append(Character.toUpperCase(words[i].charAt(0)));
            if (words[i].length() > 1)
            {
                sb.append(words[i].substring(1));
            }
        }
    }
    return sb.toString();
}