Como colocar em maiúscula o primeiro caractere de cada palavra em uma string

421

Existe uma função incorporada ao Java que capitaliza o primeiro caractere de cada palavra em uma String e não afeta as outras?

Exemplos:

  • jon skeet -> Jon Skeet
  • miles o'Brien-> Miles O'Brien(B permanece em capital, isso exclui o caso do título)
  • old mcdonald-> Old Mcdonald*

* ( Old McDonaldseria encontrado também, mas não espero que seja TÃO inteligente.)

Uma rápida olhada na documentação das seqüências Java revela apenas toUpperCase()e toLowerCase(), é claro, que não fornece o comportamento desejado. Naturalmente, os resultados do Google são dominados por essas duas funções. Parece uma roda que já deve ter sido inventada, então não custa nada pedir para que eu possa usá-la no futuro.

WillfulWizard
fonte
18
Que tal old mcdonald? Isso deveria se tornar Old McDonald?
22712 Bart Kiers
2
Não espero que a função seja tão inteligente. (Embora, se você tiver uma, ficaria feliz em vê-la.) Basta subir a primeira letra após o espaço em branco, mas ignore o resto.
WillfulWizard
1
Você não seria capaz de encontrar um algoritmo que lide adequadamente com maiúsculas e minúsculas após o fato ... desde que haja pares de nomes, um dos quais pode estar correto para uma determinada pessoa, como MacDonald e Macdonald, a função seria não tem como saber o que está correto. É melhor fazer o que você fez, apesar de alguns nomes errados (como von Neumann).
Dave DuPlantis
Tente Burger King ...
Magno C

Respostas:

732

WordUtils.capitalize(str)(do apache commons-text )

(Nota: se você precisar "fOO BAr"se tornar "Foo Bar", use-o capitalizeFully(..))

Bozho
fonte
5
Eu acho que você quer dizer WordUtils.capitalize (str). Veja API para detalhes.
31119 Doggen Hans Doggen
84
Mantendo minha filosofia de sempre votar em respostas que se referem às bibliotecas comuns.
Ravi Wallau
11
Para alterar a não primeira letra para as palavras em minúsculas, use capitalizeFully (str).
Umesh Rajbhandari
5
Esta solução está realmente correta ? não está na minha opinião! Se você deseja capitalizar "LAMborghini", deseja "Lamborghini" no final. Então WordUtils.capitalizeFully(str)é a solução.
basZero
3
@BasZero é a resposta certa para a pergunta. Vou incluir a versão completa como um comentário.
precisa saber é
229

Se você estiver preocupado apenas com a primeira letra da primeira palavra em maiúscula:

private String capitalize(final String line) {
   return Character.toUpperCase(line.charAt(0)) + line.substring(1);
}
Nick Bolton
fonte
3
isso só muda a primeira letra da primeira palavra
Chrizzz
28
De fato, essa era minha intenção.
Nick Bolton
13
@nbolton - mas ignora explicitamente a intenção da pergunta e falha nos mesmos casos apresentados nesse exemplo - e acrescenta pouco ou nada às respostas dadas anteriormente!
David Manheim
17
Este pedaço de código não é seguro contra falhas! Imagine lineser nulo ou ter um comprimento de <2.
stk
1
Ainda assim, retorne Character.toUpperCase (word.charAt (0)) + word.substring (1) .toLowerCase ()
Exceptyon
72

O método a seguir converte todas as letras em maiúsculas / minúsculas, dependendo da sua posição perto de um espaço ou de outros caracteres especiais.

public static String capitalizeString(String string) {
  char[] chars = string.toLowerCase().toCharArray();
  boolean found = false;
  for (int i = 0; i < chars.length; i++) {
    if (!found && Character.isLetter(chars[i])) {
      chars[i] = Character.toUpperCase(chars[i]);
      found = true;
    } else if (Character.isWhitespace(chars[i]) || chars[i]=='.' || chars[i]=='\'') { // You can add other chars here
      found = false;
    }
  }
  return String.valueOf(chars);
}
True Soft
fonte
Gostaria de melhorar e simplificar as condições de loop: if(Character.isLetter(chars[i])) { if(!found) { chars[i] = Character.toUpperCase(chars[i]); } found = true; } else { found = false; }.
bancer
@bancer, com o seu exemplo, você não pode controlar quais caracteres não serão seguidos por uma letra maiúscula.
É verdade macia
@ TrueSoft, eu não entendo você. Por que você precisa controlar quais caracteres seguem após a letra maiúscula? Pelo que entendi, é importante que o caractere anterior não seja uma letra e meu exemplo garante isso. Apenas substitua seu bloco if-else-if pelo meu bloco if-else e execute um teste.
bancer
@ TrueSoft, para maior clareza, eu mudaria o nome foundpara previousCharIsLetter.
bancer
9
Eu gosto de ter respostas que não usam a biblioteca comum, porque de vez em quando você não pode usá-lo.
Heckman
38

Tente desta maneira muito simples

exemplo givenString = "ram é bom garoto"

public static String toTitleCase(String givenString) {
    String[] arr = givenString.split(" ");
    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < arr.length; i++) {
        sb.append(Character.toUpperCase(arr[i].charAt(0)))
            .append(arr[i].substring(1)).append(" ");
    }          
    return sb.toString().trim();
}  

A saída será: Ram Is Good Boy

Neelam Singh
fonte
1
esse código causou um
erro fatal
32
@ Chrishrz, portanto, não confirme o código que você não testou ... Se você fornecer uma string vazia, ela trava. A culpa é sua, não da Neelam.
Reinherd
1
Se houver um espaço no final, então ele está falhando então eu adicionei guarnição () em primeiro lugar e seqüência split com space.It funcionou perfeitamente
Hanuman
Caso alguém esteja procurando por sua versão do Kotlin, aqui está: stackoverflow.com/a/55390188/1708390
erros acontecem
16

Eu escrevi uma classe pequena para colocar todas as palavras em maiúsculas em uma String.

Opcional multiple delimiters, cada um com seu comportamento (use letras maiúsculas antes, depois ou ambas, para lidar com casos como O'Brian);

Opcional Locale;

Não rompa com Surrogate Pairs.

DEMONSTRAÇÃO AO VIVO

Resultado:

====================================
 SIMPLE USAGE
====================================
Source: cApItAlIzE this string after WHITE SPACES
Output: Capitalize This String After White Spaces

====================================
 SINGLE CUSTOM-DELIMITER USAGE
====================================
Source: capitalize this string ONLY before'and''after'''APEX
Output: Capitalize this string only beforE'AnD''AfteR'''Apex

====================================
 MULTIPLE CUSTOM-DELIMITER USAGE
====================================
Source: capitalize this string AFTER SPACES, BEFORE'APEX, and #AFTER AND BEFORE# NUMBER SIGN (#)
Output: Capitalize This String After Spaces, BeforE'apex, And #After And BeforE# Number Sign (#)

====================================
 SIMPLE USAGE WITH CUSTOM LOCALE
====================================
Source: Uniforming the first and last vowels (different kind of 'i's) of the Turkish word D[İ]YARBAK[I]R (DİYARBAKIR) 
Output: Uniforming The First And Last Vowels (different Kind Of 'i's) Of The Turkish Word D[i]yarbak[i]r (diyarbakir) 

====================================
 SIMPLE USAGE WITH A SURROGATE PAIR 
====================================
Source: ab 𐐂c de à
Output: Ab 𐐪c De À

Nota: a primeira letra sempre será maiúscula (edite a fonte se você não quiser).

Compartilhe seus comentários e ajude-me a encontrar erros ou melhorar o código ...

Código:

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;

public class WordsCapitalizer {

    public static String capitalizeEveryWord(String source) {
        return capitalizeEveryWord(source,null,null);
    }

    public static String capitalizeEveryWord(String source, Locale locale) {
        return capitalizeEveryWord(source,null,locale);
    }

    public static String capitalizeEveryWord(String source, List<Delimiter> delimiters, Locale locale) {
        char[] chars; 

        if (delimiters == null || delimiters.size() == 0)
            delimiters = getDefaultDelimiters();                

        // If Locale specified, i18n toLowerCase is executed, to handle specific behaviors (eg. Turkish dotted and dotless 'i')
        if (locale!=null)
            chars = source.toLowerCase(locale).toCharArray();
        else 
            chars = source.toLowerCase().toCharArray();

        // First charachter ALWAYS capitalized, if it is a Letter.
        if (chars.length>0 && Character.isLetter(chars[0]) && !isSurrogate(chars[0])){
            chars[0] = Character.toUpperCase(chars[0]);
        }

        for (int i = 0; i < chars.length; i++) {
            if (!isSurrogate(chars[i]) && !Character.isLetter(chars[i])) {
                // Current char is not a Letter; gonna check if it is a delimitrer.
                for (Delimiter delimiter : delimiters){
                    if (delimiter.getDelimiter()==chars[i]){
                        // Delimiter found, applying rules...                       
                        if (delimiter.capitalizeBefore() && i>0 
                            && Character.isLetter(chars[i-1]) && !isSurrogate(chars[i-1]))
                        {   // previous character is a Letter and I have to capitalize it
                            chars[i-1] = Character.toUpperCase(chars[i-1]);
                        }
                        if (delimiter.capitalizeAfter() && i<chars.length-1 
                            && Character.isLetter(chars[i+1]) && !isSurrogate(chars[i+1]))
                        {   // next character is a Letter and I have to capitalize it
                            chars[i+1] = Character.toUpperCase(chars[i+1]);
                        }
                        break;
                    }
                } 
            }
        }
        return String.valueOf(chars);
    }


    private static boolean isSurrogate(char chr){
        // Check if the current character is part of an UTF-16 Surrogate Pair.  
        // Note: not validating the pair, just used to bypass (any found part of) it.
        return (Character.isHighSurrogate(chr) || Character.isLowSurrogate(chr));
    }       

    private static List<Delimiter> getDefaultDelimiters(){
        // If no delimiter specified, "Capitalize after space" rule is set by default. 
        List<Delimiter> delimiters = new ArrayList<Delimiter>();
        delimiters.add(new Delimiter(Behavior.CAPITALIZE_AFTER_MARKER, ' '));
        return delimiters;
    } 

    public static class Delimiter {
        private Behavior behavior;
        private char delimiter;

        public Delimiter(Behavior behavior, char delimiter) {
            super();
            this.behavior = behavior;
            this.delimiter = delimiter;
        }

        public boolean capitalizeBefore(){
            return (behavior.equals(Behavior.CAPITALIZE_BEFORE_MARKER)
                    || behavior.equals(Behavior.CAPITALIZE_BEFORE_AND_AFTER_MARKER));
        }

        public boolean capitalizeAfter(){
            return (behavior.equals(Behavior.CAPITALIZE_AFTER_MARKER)
                    || behavior.equals(Behavior.CAPITALIZE_BEFORE_AND_AFTER_MARKER));
        }

        public char getDelimiter() {
            return delimiter;
        }
    }

    public static enum Behavior {
        CAPITALIZE_AFTER_MARKER(0),
        CAPITALIZE_BEFORE_MARKER(1),
        CAPITALIZE_BEFORE_AND_AFTER_MARKER(2);                      

        private int value;          

        private Behavior(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }           
    } 
Andrea Ligios
fonte
15
String toBeCapped = "i want this sentence capitalized";

String[] tokens = toBeCapped.split("\\s");
toBeCapped = "";

for(int i = 0; i < tokens.length; i++){
    char capLetter = Character.toUpperCase(tokens[i].charAt(0));
    toBeCapped +=  " " + capLetter + tokens[i].substring(1);
}
toBeCapped = toBeCapped.trim();
Reid Mac
fonte
1
Hmmm, acho que a segunda linha no loop for deve ler: toBeCapped + = "" + capLetter + tokens [i] .substring (1, tokens [i] .length ());
jengelsma
1
Mas esta solução adicionará um espaço em branco no início. Então, você pode precisar fazer o ajuste esquerdo.
precisa
13

Eu fiz uma solução em Java 8 que é IMHO mais legível.

public String firstLetterCapitalWithSingleSpace(final String words) {
    return Stream.of(words.trim().split("\\s"))
    .filter(word -> word.length() > 0)
    .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1))
    .collect(Collectors.joining(" "));
}

O Gist para esta solução pode ser encontrado aqui: https://gist.github.com/Hylke1982/166a792313c5e2df9d31

Hylke1982
fonte
10

Usar org.apache.commons.lang.StringUtilstorna muito simples.

capitalizeStr = StringUtils.capitalize(str);
Amir Bareket
fonte
2
@Ash StringUtils.capitalise(str)está obsoleto. Veja: commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/…
Navigatron
Isso coloca apenas em maiúscula o primeiro caractere da sequência e não o primeiro caractere de cada palavra na sequência. WordUtils só é preterido porque ele passou de commons lang para commons texto commons.apache.org/proper/commons-text/javadocs/api-release/org/...
opticyclic
Não é uma boa idéia usar uma biblioteca externa para pouca tarefa.
Stack Overflow
7

Com este código simples :

String example="hello";

example=example.substring(0,1).toUpperCase()+example.substring(1, example.length());

System.out.println(example);

Resultado: Olá

Adrian
fonte
6
o que dizer OLÁ ele retorna OLÁ mas espera Olá assim que você deve usar toLowerCase () na segunda SubString
Trikaldarshi
5

Estou usando a seguinte função. Eu acho que é mais rápido no desempenho.

public static String capitalize(String text){
    String c = (text != null)? text.trim() : "";
    String[] words = c.split(" ");
    String result = "";
    for(String w : words){
        result += (w.length() > 1? w.substring(0, 1).toUpperCase(Locale.US) + w.substring(1, w.length()).toLowerCase(Locale.US) : w) + " ";
    }
    return result.trim();
}
Tassadar
fonte
3
Sempre use StringBuilder quando você concatenar em vez de + =
chitgoks
2
Por que você acha que é mais rápido?
Peter Mortensen
5

Do Java 9 ou superior

você pode usar String::replaceAllassim:

public static void upperCaseAllFirstCharacter(String text) {
    String regex = "\\b(.)(.*?)\\b";
    String result = Pattern.compile(regex).matcher(text).replaceAll(
            matche -> matche.group(1).toUpperCase() + matche.group(2)
    );

    System.out.println(result);
}

Exemplo:

upperCaseAllFirstCharacter("hello this is Just a test");

Saídas

Hello This Is Just A Test
YCF_L
fonte
4

Use o método Split para dividir sua sequência em palavras e, em seguida, use as funções incorporadas para colocar em maiúscula cada palavra e depois anexá-las.

Pseudo-código (ish)

string = "the sentence you want to apply caps to";
words = string.split(" ") 
string = ""
for(String w: words)

//This line is an easy way to capitalize a word
    word = word.toUpperCase().replace(word.substring(1), word.substring(1).toLowerCase())

    string += word

No final, a string se parece com "A frase à qual você deseja aplicar maiúsculas"

Paulo
fonte
4

Isso pode ser útil se você precisar capitalizar títulos. Coloca em maiúscula cada substring delimitado por " ", exceto para cadeias especificadas como "a"ou "the". Ainda não o executei porque é tarde, deve ficar bem. Usa o Apache Commons StringUtils.join()em um ponto. Você pode substituí-lo por um loop simples, se desejar.

private static String capitalize(String string) {
    if (string == null) return null;
    String[] wordArray = string.split(" "); // Split string to analyze word by word.
    int i = 0;
lowercase:
    for (String word : wordArray) {
        if (word != wordArray[0]) { // First word always in capital
            String [] lowercaseWords = {"a", "an", "as", "and", "although", "at", "because", "but", "by", "for", "in", "nor", "of", "on", "or", "so", "the", "to", "up", "yet"};
            for (String word2 : lowercaseWords) {
                if (word.equals(word2)) {
                    wordArray[i] = word;
                    i++;
                    continue lowercase;
                }
            }
        }
        char[] characterArray = word.toCharArray();
        characterArray[0] = Character.toTitleCase(characterArray[0]);
        wordArray[i] = new String(characterArray);
        i++;
    }
    return StringUtils.join(wordArray, " "); // Re-join string
}
Dominykas Mostauskis
fonte
Quebra se a string tem espaços duplos, o que é idiota para entrada, mas para sua informação.
JustTrying
4
public static String toTitleCase(String word){
    return Character.toUpperCase(word.charAt(0)) + word.substring(1);
}

public static void main(String[] args){
    String phrase = "this is to be title cased";
    String[] splitPhrase = phrase.split(" ");
    String result = "";

    for(String word: splitPhrase){
        result += toTitleCase(word) + " ";
    }
    System.out.println(result.trim());
}
Taladork
fonte
Bem-vindo ao Stack Overflow! Geralmente, as respostas são muito mais úteis se incluem uma explicação sobre o que o código pretende fazer e por que isso resolve o problema sem a introdução de outros.
Neurônio
Solução mais simples de longe e evita o uso de bibliotecas externas
Billyjoker
3
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));   

System.out.println("Enter the sentence : ");

try
{
    String str = br.readLine();
    char[] str1 = new char[str.length()];

    for(int i=0; i<str.length(); i++)
    {
        str1[i] = Character.toLowerCase(str.charAt(i));
    }

    str1[0] = Character.toUpperCase(str1[0]);
    for(int i=0;i<str.length();i++)
    {
        if(str1[i] == ' ')
        {                   
            str1[i+1] =  Character.toUpperCase(str1[i+1]);
        }
        System.out.print(str1[i]);
    }
}
catch(Exception e)
{
    System.err.println("Error: " + e.getMessage());
}
Suganya
fonte
Esta é a resposta mais simples, básica e melhor para um novato como eu!
abhishah901
3

Decidi adicionar mais uma solução para colocar maiúsculas em uma string:

  • as palavras são definidas aqui como caracteres adjacentes de letra ou dígito;
  • pares substitutos também são fornecidos;
  • o código foi otimizado para desempenho; e
  • ainda é compacto.

Função:

public static String capitalize(String string) {
  final int sl = string.length();
  final StringBuilder sb = new StringBuilder(sl);
  boolean lod = false;
  for(int s = 0; s < sl; s++) {
    final int cp = string.codePointAt(s);
    sb.appendCodePoint(lod ? Character.toLowerCase(cp) : Character.toUpperCase(cp));
    lod = Character.isLetterOrDigit(cp);
    if(!Character.isBmpCodePoint(cp)) s++;
  }
  return sb.toString();
}

Chamada de exemplo:

System.out.println(capitalize("An à la carte StRiNg. Surrogate pairs: 𐐪𐐪."));

Resultado:

An À La Carte String. Surrogate Pairs: 𐐂𐐪.
Christian Grün
fonte
3

Usar:

    String text = "jon skeet, miles o'brien, old mcdonald";

    Pattern pattern = Pattern.compile("\\b([a-z])([\\w]*)");
    Matcher matcher = pattern.matcher(text);
    StringBuffer buffer = new StringBuffer();
    while (matcher.find()) {
        matcher.appendReplacement(buffer, matcher.group(1).toUpperCase() + matcher.group(2));
    }
    String capitalized = matcher.appendTail(buffer).toString();
    System.out.println(capitalized);
coalhada
fonte
Funciona perfeitamente com toLowerCase -> "Matcher matcher = pattern.matcher (text.toLowerCase ());" (Para texto de entrada como "JOHN DOE")
smillien62 13/09/19
3

Existem várias maneiras de converter a primeira letra da primeira palavra em maiúscula. Eu tenho uma ideia. É muito simples:

public String capitalize(String str){

     /* The first thing we do is remove whitespace from string */
     String c = str.replaceAll("\\s+", " ");
     String s = c.trim();
     String l = "";

     for(int i = 0; i < s.length(); i++){
          if(i == 0){                              /* Uppercase the first letter in strings */
              l += s.toUpperCase().charAt(i);
              i++;                                 /* To i = i + 1 because we don't need to add               
                                                    value i = 0 into string l */
          }

          l += s.charAt(i);

          if(s.charAt(i) == 32){                   /* If we meet whitespace (32 in ASCII Code is whitespace) */
              l += s.toUpperCase().charAt(i+1);    /* Uppercase the letter after whitespace */
              i++;                                 /* Yo i = i + 1 because we don't need to add
                                                   value whitespace into string l */
          }        
     }
     return l;
}
Phuoc Le
fonte
Obrigado por tentar adicionar uma resposta. Essa é uma idéia razoável, mas observe que já existem funções básicas e código que faz isso de maneira semelhante à que você forneceu, e as respostas aceitas já descrevem todas elas com muita clareza.
David Manheim
2
  package com.test;

 /**
   * @author Prasanth Pillai
   * @date 01-Feb-2012
   * @description : Below is the test class details
   * 
   * inputs a String from a user. Expect the String to contain spaces and    alphanumeric     characters only.
   * capitalizes all first letters of the words in the given String.
   * preserves all other characters (including spaces) in the String.
   * displays the result to the user.
   * 
   * Approach : I have followed a simple approach. However there are many string    utilities available 
   * for the same purpose. Example : WordUtils.capitalize(str) (from apache commons-lang)
   *
   */
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;

  public class Test {

public static void main(String[] args) throws IOException{
    System.out.println("Input String :\n");
    InputStreamReader converter = new InputStreamReader(System.in);
    BufferedReader in = new BufferedReader(converter);
    String inputString = in.readLine();
    int length = inputString.length();
    StringBuffer newStr = new StringBuffer(0);
    int i = 0;
    int k = 0;
    /* This is a simple approach
     * step 1: scan through the input string
     * step 2: capitalize the first letter of each word in string
     * The integer k, is used as a value to determine whether the 
     * letter is the first letter in each word in the string.
     */

    while( i < length){
        if (Character.isLetter(inputString.charAt(i))){
            if ( k == 0){
            newStr = newStr.append(Character.toUpperCase(inputString.charAt(i)));
            k = 2;
            }//this else loop is to avoid repeatation of the first letter in output string 
            else {
            newStr = newStr.append(inputString.charAt(i));
            }
        } // for the letters which are not first letter, simply append to the output string. 
        else {
            newStr = newStr.append(inputString.charAt(i));
            k=0;
        }
        i+=1;           
    }
    System.out.println("new String ->"+newStr);
    }
}
Prasanth
fonte
2

Aqui está uma função simples

public static String capEachWord(String source){
    String result = "";
    String[] splitString = source.split(" ");
    for(String target : splitString){
        result += Character.toUpperCase(target.charAt(0))
                + target.substring(1) + " ";
    }
    return result.trim();
}
Himanshu Agrawal
fonte
1
Não use corda-concation para a criação de cadeias longas, é dolorosamente lento: stackoverflow.com/questions/15177987/...
Lukas Knuth
2

Esta é apenas outra maneira de fazer isso:

private String capitalize(String line)
{
    StringTokenizer token =new StringTokenizer(line);
    String CapLine="";
    while(token.hasMoreTokens())
    {
        String tok = token.nextToken().toString();
        CapLine += Character.toUpperCase(tok.charAt(0))+ tok.substring(1)+" ";        
    }
    return CapLine.substring(0,CapLine.length()-1);
}
foobar
fonte
2

Método reutilizável para o intiCap:

    public class YarlagaddaSireeshTest{

    public static void main(String[] args) {
        String FinalStringIs = "";
        String testNames = "sireesh yarlagadda test";
        String[] name = testNames.split("\\s");

        for(String nameIs :name){
            FinalStringIs += getIntiCapString(nameIs) + ",";
        }
        System.out.println("Final Result "+ FinalStringIs);
    }

    public static String getIntiCapString(String param) {
        if(param != null && param.length()>0){          
            char[] charArray = param.toCharArray(); 
            charArray[0] = Character.toUpperCase(charArray[0]); 
            return new String(charArray); 
        }
        else {
            return "";
        }
    }
}
Sireesh Yarlagadda
fonte
2

Aqui está a minha solução.

Encontrei este problema esta noite e decidi pesquisá-lo. Eu encontrei uma resposta de Neelam Singh que estava quase lá, então decidi corrigir o problema (quebrou as cordas vazias) e causei uma falha no sistema.

O método que você está procurando é nomeado capString(String s)abaixo. Acontece "São apenas 5 da manhã aqui" em "São apenas 5 da manhã aqui".

O código é muito bem comentado, então aproveite.

package com.lincolnwdaniel.interactivestory.model;

    public class StringS {

    /**
     * @param s is a string of any length, ideally only one word
     * @return a capitalized string.
     * only the first letter of the string is made to uppercase
     */
    public static String capSingleWord(String s) {
        if(s.isEmpty() || s.length()<2) {
            return Character.toUpperCase(s.charAt(0))+"";
        } 
        else {
            return Character.toUpperCase(s.charAt(0)) + s.substring(1);
        }
    }

    /**
     *
     * @param s is a string of any length
     * @return a title cased string.
     * All first letter of each word is made to uppercase
     */
    public static String capString(String s) {
        // Check if the string is empty, if it is, return it immediately
        if(s.isEmpty()){
            return s;
        }

        // Split string on space and create array of words
        String[] arr = s.split(" ");
        // Create a string buffer to hold the new capitalized string
        StringBuffer sb = new StringBuffer();

        // Check if the array is empty (would be caused by the passage of s as an empty string [i.g "" or " "],
        // If it is, return the original string immediately
        if( arr.length < 1 ){
            return s;
        }

        for (int i = 0; i < arr.length; i++) {
            sb.append(Character.toUpperCase(arr[i].charAt(0)))
                    .append(arr[i].substring(1)).append(" ");
        }
        return sb.toString().trim();
    }
}
lwdthe1
fonte
2

1. Java 8 Streams

public static String capitalizeAll(String str) {
    if (str == null || str.isEmpty()) {
        return str;
    }

    return Arrays.stream(str.split("\\s+"))
            .map(t -> t.substring(0, 1).toUpperCase() + t.substring(1))
            .collect(Collectors.joining(" "));
}

Exemplos:

System.out.println(capitalizeAll("jon skeet")); // Jon Skeet
System.out.println(capitalizeAll("miles o'Brien")); // Miles O'Brien
System.out.println(capitalizeAll("old mcdonald")); // Old Mcdonald
System.out.println(capitalizeAll(null)); // null

Para foo bARa Foo Bar, substitua o map()método com o seguinte:

.map(t -> t.substring(0, 1).toUpperCase() + t.substring(1).toLowerCase())

2. String.replaceAll()(Java 9 ou superior)

ublic static String capitalizeAll(String str) {
    if (str == null || str.isEmpty()) {
        return str;
    }

    return Pattern.compile("\\b(.)(.*?)\\b")
            .matcher(str)
            .replaceAll(match -> match.group(1).toUpperCase() + match.group(2));
}

Exemplos:

System.out.println(capitalizeAll("12 ways to learn java")); // 12 Ways To Learn Java
System.out.println(capitalizeAll("i am atta")); // I Am Atta
System.out.println(capitalizeAll(null)); // null

3. Texto do Apache Commons

System.out.println(WordUtils.capitalize("love is everywhere")); // Love Is Everywhere
System.out.println(WordUtils.capitalize("sky, sky, blue sky!")); // Sky, Sky, Blue Sky!
System.out.println(WordUtils.capitalize(null)); // null

Para titlecase:

System.out.println(WordUtils.capitalizeFully("fOO bAR")); // Foo Bar
System.out.println(WordUtils.capitalizeFully("sKy is BLUE!")); // Sky Is Blue!

Para detalhes, consulte este tutorial .

attacomsian
fonte
1

Para aqueles que usam o Velocity no seu MVC, você pode usar o capitalizeFirstLetter()método da classe StringUtils .

Shogo Yahagi
fonte
1
String s="hi dude i                                 want apple";
    s = s.replaceAll("\\s+"," ");
    String[] split = s.split(" ");
    s="";
    for (int i = 0; i < split.length; i++) {
        split[i]=Character.toUpperCase(split[i].charAt(0))+split[i].substring(1);
        s+=split[i]+" ";
        System.out.println(split[i]);
    }
    System.out.println(s);
se sentir bem e programação
fonte
1
package corejava.string.intern;

import java.io.DataInputStream;

import java.util.ArrayList;

/*
 * wap to accept only 3 sentences and convert first character of each word into upper case
 */

public class Accept3Lines_FirstCharUppercase {

    static String line;
    static String words[];
    static ArrayList<String> list=new ArrayList<String>();

    /**
     * @param args
     */
    public static void main(String[] args) throws java.lang.Exception{

        DataInputStream read=new DataInputStream(System.in);
        System.out.println("Enter only three sentences");
        int i=0;
        while((line=read.readLine())!=null){
            method(line);       //main logic of the code
            if((i++)==2){
                break;
            }
        }
        display();
        System.out.println("\n End of the program");

    }

    /*
     * this will display all the elements in an array
     */
    public static void display(){
        for(String display:list){
            System.out.println(display);
        }
    }

    /*
     * this divide the line of string into words 
     * and first char of the each word is converted to upper case
     * and to an array list
     */
    public static void method(String lineParam){
        words=line.split("\\s");
        for(String s:words){
            String result=s.substring(0,1).toUpperCase()+s.substring(1);
            list.add(result);
        }
    }

}
Elias Sheikh
fonte
1

Se você prefere goiaba ...

String myString = ...;

String capWords = Joiner.on(' ').join(Iterables.transform(Splitter.on(' ').omitEmptyStrings().split(myString), new Function<String, String>() {
    public String apply(String input) {
        return Character.toUpperCase(input.charAt(0)) + input.substring(1);
    }
}));
aaronvargas
fonte
1
String toUpperCaseFirstLetterOnly(String str) {
    String[] words = str.split(" ");
    StringBuilder ret = new StringBuilder();
    for(int i = 0; i < words.length; i++) {
        ret.append(Character.toUpperCase(words[i].charAt(0)));
        ret.append(words[i].substring(1));
        if(i < words.length - 1) {
            ret.append(' ');
        }
    }
    return ret.toString();
}
Krunal
fonte
1

A maneira curta e precisa é a seguinte:

String name = "test";

name = (name.length() != 0) ?name.toString().toLowerCase().substring(0,1).toUpperCase().concat(name.substring(1)): name;
--------------------
Output
--------------------
Test
T 
empty
--------------------

Funciona sem erros se você tentar alterar o valor do nome para os três valores. Sem erros.

Daniel Adenew
fonte
e se for mais de uma palavra
luckyguy73