¿Cómo capitalizar la primera letra de una cadena usando Java?

Cadenas de ejemplo

one thousand only
two hundred
twenty
seven

¿Cómo cambio el primer carácter de una cadena en mayúscula y no cambio el caso de ninguna de las otras letras?

Después del cambio debería ser:

One thousand only
Two hundred
Twenty
Seven

Nota: No quiero usar apache.commons.lang.WordUtils para hacer esto.

Si solo desea poner en mayúscula la primera letra de una cadena llamada inputy dejar el resto solo:

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

Ahora outputtendrás lo que quieres. Comprueba que tienes inputal menos un personaje mucho antes de usar esto, de lo contrario obtendrás una excepción.

public String capitalizeFirstLetter(String original) {
    if (original == null || original.length() == 0) {
        return original;
    }
    return original.substring(0, 1).toUpperCase() + original.substring(1);
}

Simplemente ... una solución completa, veo que terminó combinando lo que todos los demás publicaron = P.

La forma más simple es usar la org.apache.commons.lang.StringUtilsclase

StringUtils.capitalize(Str);

Además, hay org.springframework.util.StringUtilsen Spring Framework :

StringUtils.capitalize(str);

StringUtils.capitalize(str)

de apache commons-lang .

String sentence = "ToDAY   WeAthEr   GREat";    
public static String upperCaseWords(String sentence) {
        String words[] = sentence.replaceAll("\\s+", " ").trim().split(" ");
        String newSentence = "";
        for (String word : words) {
            for (int i = 0; i < word.length(); i++)
                newSentence = newSentence + ((i == 0) ? word.substring(i, i + 1).toUpperCase(): 
                    (i != word.length() - 1) ? word.substring(i, i + 1).toLowerCase() : word.substring(i, i + 1).toLowerCase().toLowerCase() + " ");
        }

        return newSentence;
    }
//Today Weather Great

String s=t.getText().trim();
int l=s.length();
char c=Character.toUpperCase(s.charAt(0));
s=c+s.substring(1);
for(int i=1; i<l; i++)
    {
        if(s.charAt(i)==' ')
        {
            c=Character.toUpperCase(s.charAt(i+1));
            s=s.substring(0, i) + c + s.substring(i+2);
        }
    }
    t.setText(s);

Aquí tienes (espero que esto te de la idea):

/*************************************************************************
 *  Compilation:  javac Capitalize.java
 *  Execution:    java Capitalize < input.txt
 * 
 *  Read in a sequence of words from standard input and capitalize each
 *  one (make first letter uppercase; make rest lowercase).
 *
 *  % java Capitalize
 *  now is the time for all good 
 *  Now Is The Time For All Good 
 *  to be or not to be that is the question
 *  To Be Or Not To Be That Is The Question 
 *
 *  Remark: replace sequence of whitespace with a single space.
 *
 *************************************************************************/

public class Capitalize {

    public static String capitalize(String s) {
        if (s.length() == 0) return s;
        return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
    }

    public static void main(String[] args) {
        while (!StdIn.isEmpty()) {
            String line = StdIn.readLine();
            String[] words = line.split("\\s");
            for (String s : words) {
                StdOut.print(capitalize(s) + " ");
            }
            StdOut.println();
        }
    }

}

Para esto solo se necesita un código de línea simple. si String A = scanner.nextLine(); entonces necesita escribir esto para mostrar la cadena con esta primera letra en mayúscula.

System.out.println(A.substring(0, 1).toUpperCase() + A.substring(1));

Y ya está hecho.

Ejemplo usando la clase StringTokenizer:

String st = "  hello all students";
String st1;
char f;
String fs="";
StringTokenizer a= new StringTokenizer(st);
while(a.hasMoreTokens()){   
        st1=a.nextToken();
        f=Character.toUpperCase(st1.charAt(0));
        fs+=f+ st1.substring(1);
        System.out.println(fs);
} 

Solución con StringBuilder:

value = new StringBuilder()
                .append(value.substring(0, 1).toUpperCase())
                .append(value.substring(1))
                .toString();

.. basado en respuestas anteriores

Sumando todo, es una buena idea recortar el espacio en blanco adicional al comienzo de la secuencia. De lo contrario, .substring (0,1) .toUpperCase intentará capitalizar un espacio en blanco.

    public String capitalizeFirstLetter(String original) {
        if (original == null || original.length() == 0) {
            return original;
        }
        return original.trim().substring(0, 1).toUpperCase() + original.substring(1);
    }

Mi enfoque funcional. capstiliza el primer carácter de la oración después del espacio en blanco en todo el párrafo.

Para habilitar solo el primer carácter de la palabra, simplemente elimine .split ("")

           b.name.split(" ")
                 .filter { !it.isEmpty() }
                 .map { it.substring(0, 1).toUpperCase() 
                 +it.substring(1).toLowerCase() }
                  .joinToString(" ")

Actualización de julio de 2019

Actualmente, la función de biblioteca más actualizada para hacer esto está contenida en org.apache.commons.lang3.StringUtils

import org.apache.commons.lang3.StringUtils;

StringUtils.capitalize(myString);

Si está utilizando Maven, importe la dependencia en su pom.xml:

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>3.9</version>
</dependency>

Incluso para el código "simple", usaría bibliotecas. El problema no es el código per se, sino los casos de prueba ya existentes que cubren casos excepcionales. Esto podría ser null, cadenas vacías, cadenas en otros idiomas.

La parte de manipulación de palabras se ha eliminado de Apache Commons Lang. Ahora se coloca en el texto de Apache Commons . Consíguelo a través de https://search.maven.org/artifact/org.apache.commons/commons-text .

Puede usar WordUtils.capitalize (String str) de Apache Commons Text. Es más poderoso de lo que pediste. También puede capitalizar fulle (p. Ej., Fijación "oNe tousand only").

Como funciona en texto completo, uno tiene que decirle que capitalice solo la primera palabra.

WordUtils.capitalize("one thousand only", new char[0]);

Clase JUnit completa para permitir jugar con la funcionalidad:

package io.github.koppor;

import org.apache.commons.text.WordUtils;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class AppTest {

  @Test
  void test() {
    assertEquals("One thousand only", WordUtils.capitalize("one thousand only", new char[0]));
  }

}

si solo quiere poner en mayúscula la primera letra, se puede usar el siguiente código

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

En realidad, obtendrá el mejor rendimiento si evita el +operador y el uso concat()en este caso. Es la mejor opción para fusionar solo 2 cadenas (aunque no es tan bueno para muchas cadenas). En ese caso, el código se vería así:

String output = input.substring(0, 1).toUpperCase().concat(input.substring(1));

Utilizar este:

char[] chars = {Character.toUpperCase(A.charAt(0)), 
Character.toUpperCase(B.charAt(0))};
String a1 = chars[0] + A.substring(1);
String b1 = chars[1] + B.substring(1);

Dada la inputcadena:

Character.toUpperCase(input.charAt(0)) + input.substring(1).toLowerCase()

Puedes probar el siguiente código:

public string capitalize(str) {
    String[] array = str.split(" ");
    String newStr;
    for(int i = 0; i < array.length; i++) {
        newStr += array[i].substring(0,1).toUpperCase() + array[i].substring(1) + " ";
    }
    return newStr.trim();
}

public static String capitalize(String str){
        String[] inputWords = str.split(" ");
        String outputWords = "";
        for (String word : inputWords){
            if (!word.isEmpty()){
                outputWords = outputWords + " "+StringUtils.capitalize(word);
            }
        }
        return outputWords;
    }

Me gustaría agregar un cheque NULO e IndexOutOfBoundsException en la respuesta aceptada.

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

Código Java:

  class Main {
      public static void main(String[] args) {
        System.out.println("Capitalize first letter ");
        System.out.println("Normal  check #1      : ["+ captializeFirstLetter("one thousand only")+"]");
        System.out.println("Normal  check #2      : ["+ captializeFirstLetter("two hundred")+"]");
        System.out.println("Normal  check #3      : ["+ captializeFirstLetter("twenty")+"]");
        System.out.println("Normal  check #4      : ["+ captializeFirstLetter("seven")+"]");

        System.out.println("Single letter check   : ["+captializeFirstLetter("a")+"]");
        System.out.println("IndexOutOfBound check : ["+ captializeFirstLetter("")+"]");
        System.out.println("Null Check            : ["+ captializeFirstLetter(null)+"]");
      }

      static String captializeFirstLetter(String input){
             if(input!=null && input.length() >0){
                input = input.substring(0, 1).toUpperCase() + input.substring(1);
            }
            return input;
        }
    }

Salida:

Normal  check #1      : [One thousand only]
Normal  check #2      : [Two hundred]
Normal  check #3      : [Twenty]
Normal  check #4      : [Seven]
Single letter check   : [A]
IndexOutOfBound check : []
Null Check            : [null]

Lo siguiente le dará la misma salida consistente independientemente del valor de su inputString:

if(StringUtils.isNotBlank(inputString)) {
    inputString = StringUtils.capitalize(inputString.toLowerCase());
}

1. Usando el substring()método de String

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

    return str.substring(0, 1).toUpperCase() + str.substring(1);
}

Ahora solo llame al capitalize()método para convertir la primera letra de una cadena a mayúsculas:

System.out.println(capitalize("stackoverflow")); // Stackoverflow
System.out.println(capitalize("heLLo")); // HeLLo
System.out.println(capitalize(null)); // null

2. Apache Commons Lang

La StringUtilsclase de Commons Lang proporciona el capitalize()método que también se puede usar para este propósito:

System.out.println(StringUtils.capitalize("apache commons")); // Apache commons
System.out.println(StringUtils.capitalize("heLLO")); // HeLLO
System.out.println(StringUtils.uncapitalize(null)); // null

Agregue la siguiente dependencia a su pom.xmlarchivo (solo para Maven):

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>

Aquí hay un artículo que explica estos dos enfoques en detalle.

class Test {
     public static void main(String[] args) {
        String newString="";
        String test="Hii lets cheCk for BEING String";  
        String[] splitString = test.split(" ");
        for(int i=0; i<splitString.length; i++){
            newString= newString+ splitString[i].substring(0,1).toUpperCase() 
                    + splitString[i].substring(1,splitString[i].length()).toLowerCase()+" ";
        }
        System.out.println("the new String is "+newString);
    }
 }