Cómo poner en mayúscula el primer carácter de cada palabra en una cadena

421

¿Existe una función integrada en Java que capitaliza el primer carácter de cada palabra en una cadena y no afecta a las demás?

Ejemplos:

  • jon skeet -> Jon Skeet
  • miles o'Brien-> Miles O'Brien(B sigue siendo capital, esto descarta el caso del título)
  • old mcdonald-> Old Mcdonald*

* (también Old McDonaldsería encontrar, pero no espero que sea TAN inteligente).

Un vistazo rápido a la documentación de cadenas de Java solo revela toUpperCase()y toLowerCase(), por supuesto, no proporciona el comportamiento deseado. Naturalmente, los resultados de Google están dominados por esas dos funciones. Parece una rueda que ya debe haberse inventado, por lo que no estaría de más preguntar para poder usarla en el futuro.

WillfulWizard
fuente
18
¿Qué hay de old mcdonald? ¿Debería ser eso Old McDonald?
Bart Kiers
2
No espero que la función sea tan inteligente. (Aunque si tiene una, me encantaría verla). Solo suba la primera letra después del espacio en blanco, pero ignore el resto.
WillfulWizard
1
De todos modos, no podría encontrar un algoritmo que maneje correctamente la capitalización de nombres después del hecho ... siempre que haya pares de nombres, cualquiera de los cuales puede ser correcto para una persona determinada, como MacDonald y Macdonald, la función sería No tengo forma de saber cuál era la correcta. Es mejor hacer lo que hiciste, aunque todavía obtendrás algunos nombres incorrectos (como von Neumann).
Dave DuPlantis
Prueba Burger King ...
Magno C

Respuestas:

732

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

(Nota: si necesita "fOO BAr"convertirse "Foo Bar", use capitalizeFully(..)en su lugar)

Bozho
fuente
55
Creo que te refieres a WordUtils.capitalize (str). Ver API para más detalles.
Hans Doggen
84
Manteniendo mi filosofía de votar siempre las respuestas que se refieren a las bibliotecas comunes.
Ravi Wallau
11
Para cambiar la letra que no es la primera letra a minúsculas, use capitalizeFully (str).
Umesh Rajbhandari
55
¿Es esta solución realmente correcta ? No es en mi opinión! Si quiere capitalizar "LAMborghini", quiere "Lamborghini" al final. Así WordUtils.capitalizeFully(str)es la solución.
basZero
3
@BasZero es la respuesta correcta a la pregunta formulada. Incluiré la versión completa como comentario.
Bozho
229

Si solo le preocupa que la primera letra de la primera palabra esté en mayúscula:

private String capitalize(final String line) {
   return Character.toUpperCase(line.charAt(0)) + line.substring(1);
}
Nick Bolton
fuente
3
esto solo cambia la primera letra de la primera palabra
Chrizzz
28
De hecho, esta era mi intención.
Nick Bolton
13
@nbolton - Pero ignora explícitamente la intención de la pregunta, y falla en los mismos casos dados en ese ejemplo, ¡y agrega poco o nada a las respuestas dadas anteriormente!
David Manheim
17
¡Este código no es a prueba de choques! Imagine lineser nulo o tener una longitud de <2.
stk
1
aún así, devuelve Character.toUpperCase (word.charAt (0)) + word.substring (1) .toLowerCase ()
Excepcion
72

El siguiente método convierte todas las letras en mayúsculas / minúsculas, dependiendo de su posición cerca de un espacio u otros caracteres especiales.

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);
}
Cierto suave
fuente
Me gustaría mejorar y simplificar las condiciones del bucle: if(Character.isLetter(chars[i])) { if(!found) { chars[i] = Character.toUpperCase(chars[i]); } found = true; } else { found = false; }.
bancer
@bancer, con tu ejemplo no puedes controlar qué caracteres no irán seguidos de una letra mayúscula.
True Soft
@TrueSoft, no te entiendo. ¿Por qué necesita controlar qué caracteres siguen después de la letra mayúscula? Como entendí, es importante que el carácter anterior no sea una letra y mi ejemplo lo asegura. Simplemente reemplace su bloque if-else-if con mi bloque if-else y ejecute una prueba.
bancer
@TrueSoft, para mayor claridad me gustaría cambiar el nombre founda previousCharIsLetter.
bancer
99
Me gusta tener respuestas que no usan la biblioteca commons, porque de vez en cuando no puedes usarla.
Heckman
39

Prueba esta manera muy simple

ejemplo givenString = "ram es buen chico"

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

La salida será: Ram Is Good Boy

Neelam Singh
fuente
1
este código hizo que nuestro servidor se bloquee: java.lang.StringIndexOutOfBoundsException: Índice de cadena fuera de rango: 0
Chrizzz
32
@Chrizzz, así que no confirme el código que no probó ... Si proporciona una cadena vacía, se bloquea. Tu culpa, no la de Neelam.
Reinherd
1
Si hay un espacio al final, entonces se está bloqueando, luego agregué trim () primero y dividí la cadena con espacio. Funcionó perfectamente
Hanuman
En caso de que alguien esté buscando su versión de Kotlin, aquí está: stackoverflow.com/a/55390188/1708390
errores ocurren el
16

He escrito una pequeña clase para capitalizar todas las palabras en una cadena.

Opcional multiple delimiters, cada uno con su comportamiento (capitalizar antes, después o ambos, para manejar casos como O'Brian);

Opcional Locale;

No rompas con Surrogate Pairs.

DEMO EN VIVO

Salida:

====================================
 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: la primera letra siempre estará en mayúscula (edite la fuente si no lo desea).

Comparta sus comentarios y ayúdeme a encontrar errores o mejorar el 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
fuente
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
fuente
1
Hmmm, creo que la segunda línea en el bucle for debería leer: toBeCapped + = "" + capLetter + tokens [i] .substring (1, tokens [i] .length ());
jengelsma
1
Pero esta solución agregará un espacio en blanco al comienzo. Por lo tanto, es posible que deba hacer un recorte izquierdo.
Kamalakannan J
13

Hice una solución en Java 8 que en mi humilde opinión es más legible.

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(" "));
}

La esencia de esta solución se puede encontrar aquí: https://gist.github.com/Hylke1982/166a792313c5e2df9d31

Hylke1982
fuente
10

El uso lo org.apache.commons.lang.StringUtilshace muy simple.

capitalizeStr = StringUtils.capitalize(str);
Amir Bareket
fuente
2
@Ash StringUtils.capitalise(str)está en desuso. Ver: commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/…
Navigatron
Esto solo capitaliza el primer carácter de la cadena, no el primer carácter de cada palabra en la cadena. WordUtils solo está en desuso porque se ha movido de commons lang a commons text commons.apache.org/proper/commons-text/javadocs/api-release/org/…
opticyclic
No es una buena idea usar una biblioteca externa para pequeñas tareas.
Desbordamiento de pila
7

Con este simple código :

String example="hello";

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

System.out.println(example);

Resultado: Hola

Adrian
fuente
66
¿Qué hay de HOLA? Devuelve HOLA, pero esperaba Hola, así que usará toLowerCase () en la segunda Subcadena
Trikaldarshi el
5

Estoy usando la siguiente función. Creo que es más rápido en rendimiento.

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
fuente
3
Siempre use StringBuilder cuando concatene en lugar de + =
chitgoks
2
¿Por qué crees que es más rápido?
Peter Mortensen
5

Desde Java 9+

puedes usar String::replaceAllasí:

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

Ejemplo:

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

Salidas

Hello This Is Just A Test
YCF_L
fuente
4

Use el método Split para dividir su cadena en palabras, luego use las funciones de cadena incorporadas para capitalizar cada palabra, luego agregue juntas.

Pseudocó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

Al final, la cadena se parece a "La oración a la que desea aplicar mayúsculas"

Pablo
fuente
4

Esto puede ser útil si necesita capitalizar títulos. Capitaliza cada subcadena delimitada por " ", excepto las cadenas especificadas como "a"o "the". No lo he ejecutado todavía porque es tarde, aunque debería estar bien. Utiliza Apache Commons StringUtils.join()en un punto. Puede sustituirlo con un bucle simple si lo desea.

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
fuente
Se rompe si la cadena tiene espacios dobles, lo cual es tonto para la entrada, pero para su información.
Solo intentaba el
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
fuente
¡Bienvenido a Stack Overflow! En general, las respuestas son mucho más útiles si incluyen una explicación de lo que se pretende que haga el código y por qué eso resuelve el problema sin introducir otros.
Neurona
La solución más simple con diferencia y evita el uso de
librerías
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
fuente
¡Esta es la respuesta más simple, básica y mejor para un novato como yo!
abhishah901
3

Decidí agregar una solución más para poner en mayúscula las palabras en una cadena:

  • las palabras se definen aquí como caracteres adyacentes de letras o dígitos;
  • también se proporcionan pares sustitutos;
  • el código ha sido optimizado para el rendimiento; y
  • Todavía es compacto.

Función:

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

Llamada de ejemplo:

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

Resultado:

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

Utilizar:

    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);
cuajada0
fuente
Funciona perfectamente con toLowerCase -> "Matcher matcher = pattern.matcher (text.toLowerCase ());" (Para texto de entrada como "JOHN DOE")
smillien62
3

Hay muchas maneras de convertir la primera letra de la primera palabra en mayúscula. Tengo una idea. Es muy simple:

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
fuente
Gracias por intentar agregar una respuesta. Esta es una idea razonable, pero tenga en cuenta que hay funciones básicas que ya lo hacen, y un código que lo hace de manera similar a lo que proporcionó, y las respuestas aceptadas ya las describen muy claramente.
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
fuente
2

Aquí hay una función simple

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
fuente
1
No use la concatenación de cadenas para crear cadenas largas, es dolorosamente lento: stackoverflow.com/questions/15177987/…
Lukas Knuth
2

Esta es solo otra forma de hacerlo:

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
fuente
2

Método reutilizable para 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
fuente
2

Aquí está mi solución.

Me encontré con este problema esta noche y decidí buscarlo. Encontré una respuesta de Neelam Singh que casi estaba allí, así que decidí solucionar el problema (se rompió en cadenas vacías) y causé un bloqueo del sistema.

El método que está buscando se nombra a capString(String s)continuación. Convierte "Son solo las 5 am aquí" en "Son solo las 5 am aquí".

El código está bastante bien comentado, así que disfrútalo.

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
fuente
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(" "));
}

Ejemplos:

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 bARque Foo Bar, reemplace el map()método con la siguiente:

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

2. String.replaceAll()(Java 9+)

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

Ejemplos:

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 de 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

Por titulo:

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

Para más detalles, consulte este tutorial .

Attacomsian
fuente
1

Para aquellos de ustedes que usan Velocity en su MVC, pueden usar el capitalizeFirstLetter()método de la clase StringUtils .

Shogo Yahagi
fuente
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);
sentirse bien y programar
fuente
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
fuente
1

Si prefieres guayaba ...

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
fuente
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
fuente
1

La forma corta y precisa es la siguiente:

String name = "test";

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

Funciona sin error si intenta cambiar el valor del nombre a los tres valores. Sin errores

Daniel Adenew
fuente
¿y si es más de una palabra
luckyguy73