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

Estoy usando Java para obtener una entrada de String del usuario. Estoy tratando de poner en mayúscula la primera letra de esta entrada.

Intenté esto:

 String name; BufferedReader br = new InputStreamReader(System.in); String s1 = name.charAt(0).toUppercase()); System.out.println(s1 + name.substring(1)); 

que condujo a estos errores de comstackción:

  • No coincide el tipo: no se puede convertir de InputStreamReader a BufferedReader

  • No se puede invocar toUppercase () en el tipo primitivo char

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

Con tu ejemplo:

 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(..) desde commons-lang

El código de versión más corto / más rápido para poner en mayúscula la primera letra de una Cadena es:

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

el valor del name es "Stackoverflow"

Lo que quieres hacer es probablemente esto:

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

(convierte el primer carácter en mayúscula y agrega el rest de la cadena original)

Además, crea un lector de flujo de entrada, pero nunca lee ninguna línea. Por lo tanto, el name siempre será null .

Esto debería funcionar:

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

Use la biblioteca común de Apache. Libere su cerebro de estos productos y evite el puntero nulo y el índice fuera de las excepciones encuadernadas

Paso 1:

Importe la biblioteca común de lang de apache poniendo esto en dependencias de build.gradle

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

Paso 2:

Si está seguro de que su cadena está en minúsculas, o todo lo que necesita es inicializar la primera letra, llame directamente

 StringUtils.capitalize(yourString); 

Si quiere asegurarse de que solo la primera letra esté en mayúscula, como hacer esto para una enum , llame a toLowerCase() primero y tenga en cuenta que arrojará NullPointerException si la cadena de entrada es nula.

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

Aquí hay más ejemplos proporcionados por apache. es una excepción libre

 StringUtils.capitalize(null) = null StringUtils.capitalize("") = "" StringUtils.capitalize("cat") = "Cat" StringUtils.capitalize("cAt") = "CAt" StringUtils.capitalize("'cat'") = "'cat'" 

Nota:

WordUtils también se incluye en esta biblioteca, pero está en desuso. Por favor no uses eso.

WordUtils.capitalize(java.lang.String) de Apache Commons .

Debajo de la solución funcionará.

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

No puede utilizar toUpperCase () en char primitivo, pero puede hacer String entero a mayúsculas primero, luego tomar el primer char, y luego anexar a la subcadena como se muestra arriba.

Use WordUtils.capitalize(str) .

Establezca la cadena en minúscula, luego configure la primera letra en la parte superior de la siguiente manera:

  userName = userName.toLowerCase(); 

luego para poner en mayúscula la primera letra:

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

subcadena es solo obtener una parte de una cadena más grande, luego los estamos combinando nuevamente.

El más corto también:

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

Trabajó para mi.

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

Puede usar substring() para hacer esto.

Pero hay dos casos diferentes:

Caso 1

Si la String que está capitalizando está destinada a ser legible por el ser humano, también debe especificar la configuración regional predeterminada:

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

Caso 2

Si el String que está capitalizando está destinado a ser legible por máquina, evite usar Locale.getDefault() porque la cadena que se devuelve será incoherente en diferentes regiones, y en este caso siempre especifique la misma configuración regional (por ejemplo, toUpperCase(Locale.ENGLISH) ). Esto asegurará que las cadenas que está utilizando para el procesamiento interno sean consistentes, lo que le ayudará a evitar errores difíciles de encontrar.

Nota: No tiene que especificar Locale.getDefault() para toLowerCase() , ya que esto se hace automáticamente.

En Android Studio

Agregue esta dependencia a su build.gradle (Module: app)

 dependencies { ... compile 'org.apache.commons:commons-lang3:3.1' ... } 

Ahora puedes usar

 String string = "STRING WITH ALL CAPPS AND SPACES"; string = string.toLowerCase(); // Make all lowercase if you have caps someTextView.setText(WordUtils.capitalize(string)); 

¿Qué pasa con WordUtils.capitalizeFully () ?

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

Esto es solo para mostrarte, que no estabas tan equivocado.

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

Nota: Esta no es en absoluto la mejor manera de hacerlo. Esto es solo para mostrarle al OP que también se puede hacer usando charAt() . 😉

También puedes probar esto:

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

Esto es mejor (optimizado) que con el uso de subcadenas. (pero no se preocupe por una cuerda pequeña)

prueba este

Lo que hace este método es que considere el trabajo “hello world” este método conviértalo en “Hello World” capitalizando el comienzo de cada palabra.

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

Eche un vistazo a ACL WordUtils.

WordUtils.capitalize (“su cadena”) == “Su cadena”

¿Cómo mayúsculas en cada primera letra de una cadena?

 public static String capitalizer(final String texto) { // split words String[] palavras = texto.split(" "); StringBuilder sb = new StringBuilder(); // list of word exceptions List excessoes = new ArrayList(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(); } 
 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); } 

Esto funcionará

 char[] array = value.toCharArray(); array[0] = Character.toUpperCase(array[0]); String result = new String(array); 

Puedes usar el siguiente código:

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

Muchas de las respuestas son muy útiles, así que las utilicé para crear un método para convertir cualquier cadena en un título (el primer carácter en mayúscula):

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

Puedes usar el siguiente código:

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

prueba de ejemplo con JUnit:

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

Para poner en mayúscula el primer carácter de cada palabra en una cadena,

primero necesita obtener cada palabra de esa cadena y para esta secuencia dividida donde haya espacio utilizando el método de división como se muestra a continuación y almacenar cada palabra en una matriz. Luego crea una cadena vacía. Después de eso, usando el método substring (), obtenga el primer carácter y el carácter restante de la palabra correspondiente y guárdelos en dos variables diferentes.

Luego, al usar el método toUpperCase (), capitalice el primer carácter y agregue los caracteres restantes como se muestra a continuación a esa cadena vacía.

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

El siguiente ejemplo también escribe en mayúscula las palabras después de caracteres especiales como [/ -]

  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 

gracias. He leído algunos de los comentarios y vine con lo siguiente

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

Espero que ayude a la buena suerte

La respuesta de Ameen Mahheen es buena, pero si tenemos alguna cadena con doble espacio, como “hello world”, entonces sb.append obtiene la excepción IndexOutOfBounds. Lo correcto es testear antes de esta línea, haciendo:

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

Puedes intentar esto

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

Puede usar Class WordUtils.

Supongamos que su cadena es “dirección actual” y luego use

**** texto fuerte Wordutils.capitaliz (String); salida: Dirección actual

Consulte: http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/text/WordUtils.html