如何将Java中的字符串的首字母大写？


How to capitalize the first letter of a String in Java?

我使用Java从用户那里获得一个EDCOX1×0的输入。我正试图使这个输入的第一个字母大写。

我试过这个：

1
2
3
4
5
6
7
String name;

BufferedReader br = new InputStreamReader(System.in);

String s1 = name.charAt(0).toUppercase());

System.out.println(s1 + name.substring(1));

导致这些编译器错误：

  • Type mismatch: cannot convert from InputStreamReader to BufferedReader

  • Cannot invoke toUppercase() on the primitive type char

相关讨论

1
2
3
String str ="java";
String cap = str.substring(0, 1).toUpperCase() + str.substring(1);
// cap ="Java"

用你的例子：

1
2
3
4
5
6
7
8
9
public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    // Actually use the Reader
    String name = br.readLine();
    // Don't mistake String object with a Character object
    String s1 = name.substring(0, 1).toUpperCase();
    String nameCapitalized = s1 + name.substring(1);
    System.out.println(nameCapitalized);
}
相关讨论

StringUtils.capitalize(..)郎从下议院

相关讨论

在利用短码/更快的版本是第一个字符串：

1
2
String name  ="stackoverflow";
name = name.substring(0,1).toUpperCase() + name.substring(1).toLowerCase();

的价值是"Stackoverflow"name

相关讨论

使用Apache的公共库。将您的大脑从这些东西中解放出来，并避免空指针和索引超出限制的异常。

步骤1：

导入Apache的公共语言库，将其放入build.gradle依赖项中。

1
compile 'org.apache.commons:commons-lang3:3.6'

步骤2：

如果您确定字符串的大小写都是小写，或者只需要初始化第一个字母，则直接调用

1
StringUtils.capitalize(yourString);

如果要确保只有第一个字母是大写的，如对enum这样做，请首先调用toLowerCase()，并记住，如果输入字符串为空，它将抛出NullPointerException。

1
2
StringUtils.capitalize(YourEnum.STUFF.name().toLowerCase());
StringUtils.capitalize(yourString.toLowerCase());

以下是Apache提供的更多示例。没有例外

1
2
3
4
5
StringUtils.capitalize(null)  = null
StringUtils.capitalize("")    =""
StringUtils.capitalize("cat") ="Cat"
StringUtils.capitalize("cAt") ="CAt"
StringUtils.capitalize("'cat'") ="'cat'"

注：

WordUtils也包含在该库中，但已弃用。请不要用那个。

相关讨论

你所想的可能是这样的：

1
s1 = name.substring(0, 1).toUpperCase() + name.substring(1);

(converts第一字符的其余uppercase和增加到原来的字符串)

创建一个输入流的同时，你的读者，但不读任何线。因此nullname将永远是。

这应该工作。

1
2
3
BufferedReader br = new InputstreamReader(System.in);
String name = br.readLine();
String s1 = name.substring(0, 1).toUpperCase() + name.substring(1);

WordUtils.capitalize(java.lang.String)从Apache Commons。

相关讨论

下面的解决方案将起作用。

1
2
3
String A ="stackOverflow";
String ACaps = A.toUpperCase().charAt(0)+A.substring(1,A.length());
//Will print StackOverflow

不能对基元字符使用toUpperCase()，但可以先将整个字符串设为大写，然后取第一个字符，然后附加到子字符串，如上图所示。

相关讨论

使用WordUtils.capitalize(str)。

相关讨论

1
2
String str1 ="hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);

对字符串集下集箱，然后第一个对上像这样：

1
    userName = userName.toLowerCase();

然后在第一个capitalise：

1
    userName = userName.substring(0, 1).toUpperCase() + userName.substring(1).toLowerCase();

子串是刚刚在一片较大的字符串，然后我们一起结合他们的背。

相关讨论

wordutils.capitalizefully()是什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import org.apache.commons.lang3.text.WordUtils;

public class Main {

    public static void main(String[] args) {

        final String str1 ="HELLO WORLD";
        System.out.println(capitalizeFirstLetter(str1)); // output: Hello World

        final String str2 ="Hello WORLD";
        System.out.println(capitalizeFirstLetter(str2)); // output: Hello World

        final String str3 ="hello world";
        System.out.println(capitalizeFirstLetter(str3)); // output: Hello World

        final String str4 ="heLLo wORld";
        System.out.println(capitalizeFirstLetter(str4)); // output: Hello World
    }

    private static String capitalizeFirstLetter(String str) {
        return WordUtils.capitalizeFully(str);
    }
}

最短也。

1
2
3
String message ="my message";    
message = Character.toUpperCase(message.charAt(0)) + message.substring(1);
System.out.println(message)    // Will output: My message

为我工作的。

在Android的工作室

添加到您的这个build.gradle (Module: app)依赖

1
2
3
4
5
dependencies {
    ...
    compile 'org.apache.commons:commons-lang3:3.1'
    ...
}

现在你可以使用

1
2
3
4
5
String string ="STRING WITH ALL CAPPS AND SPACES";

string = string.toLowerCase(); // Make all lowercase if you have caps

someTextView.setText(WordUtils.capitalize(string));

你可以使用这一substring())。

但有两种情况：

案例1

如果你利用的是一String可读的意思是，你也应该指定默认区域设置：

1
2
String firstLetterCapitalized =
    myString.substring(0, 1).toUpperCase(Locale.getDefault()) + myString.substring(1);

案例2

如果你是一String利用机器可读的意思是避免使用，因为这是Locale.getDefault()返回字符串不一致，在不同的地区将永远在这案例，和指定的区域(例如，toUpperCase(Locale.ENGLISH))。这将确保你是使用字符串的内部处理是一致的，这将帮助你避免难找到漏洞。

注意：你没有到指定的Locale.getDefault()是toLowerCase()，这是自动完成的。

尝试这一个

那是什么这一方法不考虑的话，这个"Hello World"的方法把它利用到"Hello World"从一开始的每个字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 private String capitalizer(String word){

        String[] words = word.split("");
        StringBuilder sb = new StringBuilder();
        if (words[0].length() > 0) {
            sb.append(Character.toUpperCase(words[0].charAt(0)) + words[0].subSequence(1, words[0].length()).toString().toLowerCase());
            for (int i = 1; i < words.length; i++) {
                sb.append("");
                sb.append(Character.toUpperCase(words[i].charAt(0)) + words[i].subSequence(1, words[i].length()).toString().toLowerCase());
            }
        }
        return  sb.toString();

    }
相关讨论

这是只是为了显示你，你是不是错的。

1
2
3
4
5
6
7
8
9
10
BufferedReader br = new InputstreamReader(System.in);
// Assuming name is not blank
String name = br.readLine();

//No more error telling that you cant convert char to string
String s1 = (""+name.charAt(0)).toUppercase());
// Or, as Carlos prefers. See the comments to this post.
String s1 = Character.toString(name.charAt(0)).toUppercase());

System.out.println(s1+name.substring(1));

注意：这不是一个在所有的最好的方式做它。这是只是为了显示它的运算可以用charAt()做的好。)；

相关讨论

你可以使用下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {

    capitalizeFirstLetter("java");
    capitalizeFirstLetter("java developer");
}

public static void capitalizeFirstLetter(String text) {

    StringBuilder str = new StringBuilder();

    String[] tokens = text.split("\\s");// Can be space,comma or hyphen

    for (String token : tokens) {
        str.append(Character.toUpperCase(token.charAt(0))).append(token.substring(1)).append("");
    }
    str.toString().trim(); // Trim trailing space

    System.out.println(str);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Use this utility method to get all first letter in capital.


String captializeAllFirstLetter(String name)
    {
        char[] array = name.toCharArray();
        array[0] = Character.toUpperCase(array[0]);

        for (int i = 1; i < array.length; i++) {
            if (Character.isWhitespace(array[i - 1])) {
                array[i] = Character.toUpperCase(array[i]);
            }
        }

        return new String(array);
    }

有一个看wordutils ACL。

wordutils.capitalize("你"你的字符串的字符串，""= =)

如何上每一个字的信中的第一个实例的字符串？

这将工作

1
2
3
4
5
char[] array = value.toCharArray();

array[0] = Character.toUpperCase(array[0]);

String result = new String(array);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static String capitalizer(final String texto) {

    // split words
    String[] palavras = texto.split("");
    StringBuilder sb = new StringBuilder();

    // list of word exceptions
    List<String> excessoes = new ArrayList<String>(Arrays.asList("de","da","das","do","dos","na","nas","no","nos","a","e","o","em","com"));

    for (String palavra : palavras) {

        if (excessoes.contains(palavra.toLowerCase()))
            sb.append(palavra.toLowerCase()).append("");
        else
            sb.append(Character.toUpperCase(palavra.charAt(0))).append(palavra.substring(1).toLowerCase()).append("");
    }
    return sb.toString().trim();
}

你也可以试试这个：

1
2
3
4
5
 String s1 = br.readLine();
 char[] chars = s1.toCharArray();
 chars[0] = Character.toUpperCase(chars[0]);
 s1= new String(chars);
 System.out.println(s1);

这是一个更好的方法比用substring(优化)。(但不担心在线小字符串)

对于Java用户：

只是一个帮助方法，用于大写每个字符串。

1
2
3
4
public static String capitalize(String str)
{
    return str.substring(0, 1).toUpperCase() + str.substring(1);
}

在那之后，只需打电话给str = capitalize(str)。

对于Kotlin用户，只需拨打：

1
str.capitalize()
1
System.out.println(Character.toString(A.charAt(0)).toUpperCase()+A.substring(1));

字符串s =这是一页。

你可以使用下面的代码：

1
2
3
4
5
6
7
8
9
10
11
public static String capitalizeString(String string) {

    if (string == null || string.trim().isEmpty()) {
        return string;
    }
    char c[] = string.trim().toLowerCase().toCharArray();
    c[0] = Character.toUpperCase(c[0]);

    return new String(c);

}

例：用JUnit测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Test
public void capitalizeStringUpperCaseTest() {

    String string ="HELLO WORLD ";

    string = capitalizeString(string);

    assertThat(string, is("Hello world"));
}

@Test
public void capitalizeStringLowerCaseTest() {

    String string ="hello world ";

    string = capitalizeString(string);

    assertThat(string, is("Hello world"));
}

我发布的代码将从字符串中删除下划线(u)符号和多余的空格，并且它还将使字符串中每个新单词的第一个字母大写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
private String capitalize(String txt){
  List<String> finalTxt=new ArrayList<>();

  if(txt.contains("_")){
       txt=txt.replace("_","");
  }

  if(txt.contains("") && txt.length()>1){
       String[] tSS=txt.split("");
       for(String tSSV:tSS){ finalTxt.add(capitalize(tSSV)); }  
  }

  if(finalTxt.size()>0){
       txt="";
       for(String s:finalTxt){ txt+=s+""; }
  }

  if(txt.endsWith("") && txt.length()>1){
       txt=txt.substring(0, (txt.length()-1));
       return txt;
  }

  txt = txt.substring(0,1).toUpperCase() + txt.substring(1).toLowerCase();
  return txt;
}

其中一个答案是95%正确的，但在我的UnitTest@Ameen Maheen的解决方案中失败了，几乎是完美的。除了在输入转换为字符串数组之前，您必须修剪输入。所以完美的一个：

1
2
3
4
5
6
7
8
9
10
11
12
13
private String convertStringToName(String name) {
        name = name.trim();
        String[] words = name.split("");
        StringBuilder sb = new StringBuilder();
        if (words[0].length() > 0) {
            sb.append(Character.toUpperCase(words[0].charAt(0)) + words[0].subSequence(1, words[0].length()).toString().toLowerCase());
            for (int i = 1; i < words.length; i++) {
                sb.append("");
                sb.append(Character.toUpperCase(words[i].charAt(0)) + words[i].subSequence(1, words[i].length()).toString().toLowerCase());
            }
        }
        return sb.toString();
    }

答案是非常多的，所以我就helpful用任何方法把字符串创建一个标题(字符)，第一capitalized)：

1
2
3
4
5
static String toTitle (String s) {
      String s1 = s.substring(0,1).toUpperCase();
      String sTitle = s1 + s.substring(1);
      return sTitle;
 }

要将字符串中每个单词的第一个字符大写，

首先，您需要使用下面的split方法为这个拆分字符串获取该字符串中的每个单词(其中有任何空格)，并将每个单词存储在一个数组中。然后创建一个空字符串。然后，使用substring()方法获取相应单词的第一个字符和剩余字符，并将它们存储在两个不同的变量中。

然后，通过使用touppercase()方法，将第一个字符大写，并将下面的剩余字符添加到该空字符串中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test {  
     public static void main(String[] args)
     {
         String str="my name is khan";        // string
         String words[]=str.split("\\s");      // split each words of above string
         String capitalizedWord ="";         // create an empty string

         for(String w:words)
         {  
              String first = w.substring(0,1);    // get first character of each word
              String f_after = w.substring(1);    // get remaining character of corresponding word
              capitalizedWord += first.toUpperCase() + f_after+"";  // capitalize first character and add the remaining to the empty string and continue
         }
         System.out.println(capitalizedWord);    // print the result
     }
}
相关讨论

下面的例子也不capitalizes特殊字符如[后]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  public static String capitalize(String text) {
    char[] stringArray = text.trim().toCharArray();
    boolean wordStarted = false;
    for( int i = 0; i < stringArray.length; i++) {
      char ch = stringArray[i];
      if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '\'') {
        if( !wordStarted ) {
          stringArray[i] = Character.toUpperCase(stringArray[i]);
          wordStarted = true;
        }
      } else {
        wordStarted = false;
      }
    }
    return new String(stringArray);
  }

Example:
capitalize("that's a beautiful/wonderful life we have.We really-do")

Output:
That's A Beautiful/Wonderful Life We Have.We Really-Do
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class CapitalizeWords
{
    public static void main(String[] args)
    {
        String input ="welcome to kashmiri geeks...";

        System.out.println(input);

        String[] str = input.split("");

        for(int i=0; i< str.length; i++)
        {
            str[i] = (str[i]).substring(0,1).toUpperCase() + (str[i]).substring(1);
        }

        for(int i=0;i<str.length;i++)
        {
            System.out.print(str[i]+"");
        }


    }
}

谢谢，我已经读了一些评论，我将用以下的凸轮

1
2
3
4
5
6
public static void main(String args[])
{
String myName ="nasser";
String newName = myName.toUpperCase().charAt(0) +  myName.substring(1);
System.out.println(newName );
}

我希望它帮助好运气

答案是从mahheen Ameen如果我们有一些很好的双空间的字符串"Hello World"那样，把sb.append indexoutofbounds异常。这是正确的：在这个测试线，做

1
2
3
4
5
6
7
8
9
10
11
12
private String capitalizer(String word){
        String[] words = word.split("");
        StringBuilder sb = new StringBuilder();
        if (words[0].length() > 0) {
            sb.append(Character.toUpperCase(words[0].charAt(0)) + words[0].subSequence(1, words[0].length()).toString().toLowerCase());
            for (int i = 1; i < words.length; i++) {
                sb.append("");
                if (words[i].length() > 0) sb.append(Character.toUpperCase(words[i].charAt(0)) + words[i].subSequence(1, words[i].length()).toString().toLowerCase());
            }
        }
        return  sb.toString();
    }

你可以使用wordutils类。

"你是一suppose字符串，然后使用当前的地址"

××××××××××××××××；强textwordutils.capitaliz(字符串)地址：电流输出

参考：http：／／commons.apache.org /正常/共享/组织/ apidocs郎/ / / / lang3 Apache Commons的文本/ wordutils.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void capitalizeFirstLetter(JTextField textField) {

    try {

        if (!textField.getText().isEmpty()) {
            StringBuilder b = new StringBuilder(textField.getText());
            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());
            textField.setText(b.toString());
        }

    } catch (Exception e) {
        e.printStackTrace();
        JOptionPane.showMessageDialog(null, e,"Error", JOptionPane.ERROR_MESSAGE);
    }
}

只是reworked jorgesys代码检查和由少数几个案例，因为相关的字符串的长度。不要在我的案例是空引用检查。

1
2
3
4
5
6
7
8
9
10
 public static String capitalizeFirstLetter(@NonNull String customText){
        int count = customText.length();
        if (count == 0) {
            return customText;
        }
        if (count == 1) {
            return customText.toUpperCase();
        }
        return customText.substring(0, 1).toUpperCase() + customText.substring(1).toLowerCase();
    }

从commons.lang.stringutils，最佳答案是：

公共静态字符串大写(字符串str){斯特林；返回STR！=空&；&；(strlen=str.length())！= 0？(new stringbuffer(strlen)).append(character.toitlecase(str.charat(0)).append(str.substring(1)).tostring()：str；}

我觉得它很棒，因为它用一个字符串缓冲区包装字符串。您可以使用相同的实例根据需要操作StringBuffer。

1
2
3
4
5
6
7
8
9
10
11
12
13
String s ="first second third fourth";

        int j = 0;
        for (int i = 0; i < s.length(); i++) {

            if ((s.substring(j, i).endsWith(""))) {

                String s2 = s.substring(j, i);
                System.out.println(Character.toUpperCase(s.charAt(j))+s2.substring(1));
                j = i;
            }
        }
        System.out.println(Character.toUpperCase(s.charAt(j))+s.substring(j+1));

一种方法。

1
2
3
4
5
6
7
8
9
String input ="someТекст$T%$4??Э"; //Enter your text.
if (input == null || input.isEmpty()) {
    return"";
}

char [] chars = input.toCharArray();
chars[0] = chars[0].toUpperCase();
String res = new String(chars);
return res;

这个方法的缺点是，如果inputstring很长，那么您将有三个这样长的对象。和你一样

1
2
3
String s1 = input.substring(1).toUpperCase();
String s2 = input.substring(1, lenght);
String res = s1 + s2;

甚至

1
2
3
4
5
//check if not null.
StringBuilder buf = new StringBuilder(input);
char ch = buf.getCharAt(0).toUpperCase();
buf.setCharAt(0, ch);
return buf.toString();

另一个例子是，如何将用户输入的第一个字母大写：

1
2
3
4
5
6
7
8
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String string = br.readLine();
// handle supplementary characters
IntStream.concat(
        IntStream.of(string.codePointAt(0))
                .map(Character::toUpperCase), string.codePoints().skip(1)
)
.forEach(cp -> System.out.print(Character.toChars(cp)));

此代码将文本中的每个单词大写！

1
2
3
4
5
6
7
8
9
public String capitalizeText(String name) {
    String[] s = name.trim().toLowerCase().split("\\s+");
    name ="";
    for (String i : s){
        if(i.equals("")) return name; // or return anything you want
        name+= i.substring(0, 1).toUpperCase() + i.substring(1) +""; // uppercase first char in words
    }
    return name.trim();
}

你可以试试这个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * capitilizeFirst(null)  ->""
 * capitilizeFirst("")    ->""
 * capitilizeFirst("  ") ->""
 * capitilizeFirst(" df") ->"Df"
 * capitilizeFirst("AS")  ->"As"
 *
 * @param str input string
 * @return String with the first letter capitalized
 */
public String capitilizeFirst(String str)
{
    // assumptions that input parameter is not null is legal, as we use this function in map chain
    Function<String, String> capFirst = (String s) -> {
        String result =""; // <-- accumulator

        try { result += s.substring(0, 1).toUpperCase(); }
        catch (Throwable e) {}
        try { result += s.substring(1).toLowerCase(); }
        catch (Throwable e) {}

        return result;
    };

    return Optional.ofNullable(str)
            .map(String::trim)
            .map(capFirst)
            .orElse("");
}

那些利用信搜索第一名……

1
2
3
4
5
6
7
8
9
10
11
public static String capitaliseName(String name) {
    String collect[] = name.split("");
    String returnName ="";
    for (int i = 0; i < collect.length; i++) {
        collect[i] = collect[i].trim().toLowerCase();
        if (collect[i].isEmpty() == false) {
            returnName = returnName + collect[i].substring(0, 1).toUpperCase() + collect[i].substring(1) +"";
        }
    }
    return returnName.trim();
}

usase: capitaliseName("saurav khan");

output: Saurav Khan

试试这个，它是我的工作。

1
2
3
4
5
6
7
8
public static String capitalizeName(String name) {
    String fullName ="";
    String names[] = name.split("");
    for (String n: names) {
        fullName = fullName + n.substring(0, 1).toUpperCase() + n.toLowerCase().substring(1, n.length()) +"";
    }
    return fullName;
}