Estoy usando Java para obtener una Stringentrada 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 del compilador:

• No coinciden los tipos: 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(..) de 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 de namees"Stackoverflow"

Use la biblioteca común de Apache. Libere su cerebro de estas cosas y evite las excepciones de puntero nulo e índice fuera de límites

Paso 1:

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

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

Paso 2:

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

StringUtils.capitalize(yourString);

Si desea asegurarse de que solo la primera letra esté en mayúscula, como hacer esto para un enum, llame 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 muestras proporcionadas por apache. es libre de excepciones

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

Nota:

WordUtilstambién se incluye en esta biblioteca, pero está en desuso. Por favor no use eso.

Java:

simplemente un método auxiliar para capitalizar cada cadena.

public static String capitalize(String str)
{
    if(str == null) return str;
    return str.substring(0, 1).toUpperCase() + str.substring(1);
}

Después de eso simplemente llama str = capitalize(str)

Kotlin:

str.capitalize()

Lo que quieres hacer es probablemente esto:

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

(convierte el primer carácter a mayúsculas y agrega el resto de la cadena original)

Además, crea un lector de flujo de entrada, pero nunca lee ninguna línea. Así namesiempre 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);

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

La siguiente solución funcionará.

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

No puede usar toUpperCase () en caracteres primitivos, pero puede hacer que la Cadena entera en mayúsculas primero tome el primer carácter y luego anexar a la subcadena como se muestra arriba.

Uso WordUtils.capitalize(str).

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.

Establezca la cadena en minúsculas, luego configure la primera letra en mayúscula de esta manera:

    userName = userName.toLowerCase();

luego para poner en mayúscula la primera letra:

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

la subcadena solo está obteniendo un trozo de una cadena más grande, luego los estamos combinando nuevamente.

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

Use este método de utilidad para obtener todas las primeras letras en mayúscula.

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

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

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 la subcadena. (pero no te preocupes por la cuerda pequeña)

Puedes usar substring()para hacer esto.

Pero hay dos casos diferentes:

Caso 1

Si el uso de Stringmayúsculas está destinado a ser legible por humanos, 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 uso de Stringmayúsculas está destinado a ser legible por máquina, evite usarlo Locale.getDefault()porque la cadena que se devuelve será inconsistente 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 lo 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));

si usa SPRING :

import static org.springframework.util.StringUtils.capitalize;
...


    return capitalize(name);

NOTA: Si ya tiene la dependencia de Apache Common Lang, considere usar sus StringUtils.capitalize como sugieren otras respuestas.

IMPLEMENTACIÓN: https://github.com/spring-projects/spring-framework/blob/64440a5f04a17b3728234afaa89f57766768decb/spring-core/src/main/java/org/springframework/util/StringUtils.java#L535-L55

REF: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/StringUtils.html#capitalize-java.lang.String-

FUNCIONARÁ 101%

public class UpperCase {

    public static void main(String [] args) {

        String name;

        System.out.print("INPUT: ");
        Scanner scan = new Scanner(System.in);
        name  = scan.next();

        String upperCase = name.substring(0, 1).toUpperCase() + name.substring(1);
        System.out.println("OUTPUT: " + upperCase); 

    }

}

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 la mejor manera de hacerlo. Esto es solo para mostrarle al OP que también se puede hacer usando charAt(). ;)

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

}

prueba este

Lo que hace este método es que, considere la palabra "hola mundo", este método lo convierte en "Hola mundo", escribe con mayúscula el principio 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();

    }

Las respuestas dadas son para poner en mayúscula la primera letra de una sola palabra. use el siguiente código para capitalizar una cadena completa.

public static void main(String[] args) {
    String str = "this is a random string";
    StringBuilder capitalizedString = new StringBuilder();
    String[] splited = str.trim().split("\\s+");

    for (String string : splited) {         
        String s1 = string.substring(0, 1).toUpperCase();
        String nameCapitalized = s1 + string.substring(1);

        capitalizedString.append(nameCapitalized);
        capitalizedString.append(" ");
    }
    System.out.println(capitalizedString.toString().trim());
}

salida: This Is A Random String

Si Input es UpperCase, entonces use lo siguiente:

str.substring (0, 1) .toUpperCase () + str.substring (1) .toLowerCase ();

Si Input es LowerCase, entonces use lo siguiente:

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

Echa un vistazo a ACL WordUtils.

WordUtils.capitalize ("your string") == "Your String"

¿Cómo poner en mayúscula 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<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();
}

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

}

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

Usar commons.lang.StringUtilsla mejor respuesta es:

public static String capitalize(String str) {  
    int strLen;  
    return str != null && (strLen = str.length()) != 0 ? (new StringBuffer(strLen)).append(Character.toTitleCase(str.charAt(0))).append(str.substring(1)).toString() : str;  
}

Me parece brillante ya que envuelve la cadena con un StringBuffer. Puede manipular el StringBuffer como lo desee y utilizando la misma instancia.

Otro ejemplo más, cómo puede poner en mayúscula la primera letra de la entrada del usuario:

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String string = br.readLine();
// handle supplementary characters
IntStream.concat(
        IntStream.of(string.codePointAt(0))
                .map(Character::toUpperCase), string.codePoints().skip(1)
)
.forEach(cp -> System.out.print(Character.toChars(cp)));