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

string to uppercase java

Question

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 compilación:

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

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

Answer 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 iniciar 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 , toLowerCase() llame a toLowerCase() 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.

Answer 2

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  = ""; 
name = name.substring(0,1).toUpperCase() + name.substring(1).toLowerCase();

el valor del name es ""

Answer 3

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

Answer 4

Debajo de la solución funcionará.

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

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.

Answer 5

Eche un vistazo a ACL WordUtils.

WordUtils.capitalize ("su cadena") == "Su cadena"

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

Answer 6

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.

Answer 7

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

Answer 8

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.

Answer 9

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

Answer 10

Esto funcionará

char[] array = value.toCharArray();

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

String result = new String(array);

Answer 11

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

Answer 12

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

Answer 13

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

Answer 14

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

Answer 15

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.

Answer 16

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

Answer 17

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

Answer 18

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

Answer 19

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

}

Answer 20

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)

Answer 21

Use WordUtils.capitalize(str) .

Answer 22

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

Answer 23

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

    }

Answer 24

StringUtils.capitalize(..) desde commons-lang

Answer 25

WordUtils.capitalize(java.lang.String) de commons-lang .

Answer 26

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

Answer 27

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

Answer 28

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

Answer 29

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

Answer 30

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