J'utilise Java pour obtenir un String entrée de l'utilisateur. J'essaie de mettre en majuscule la première lettre de cette entrée.

J'ai essayé ceci:

String name;

BufferedReader br = new InputStreamReader(System.in);

String s1 = name.charAt(0).toUppercase());

System.out.println(s1 + name.substring(1));

ce qui a conduit à ces erreurs de compilation:

• Incompatibilité de type: impossible de convertir InputStreamReader en BufferedReader

• Impossible d'appeler toUppercase () sur le caractère de type primitif

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

Avec votre exemple:

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

Le code de version plus court / plus rapide pour mettre en majuscule la première lettre d'une chaîne est:

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

la valeur de nameest"Stackoverflow"

Utilisez la bibliothèque commune d'Apache. Libérez votre cerveau de ces éléments et évitez les pointeurs nuls et les exceptions hors index

Étape 1:

Importez la bibliothèque lang commune d'Apache en la mettant dans les build.gradledépendances

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

Étape 2:

Si vous êtes sûr que votre chaîne est entièrement en minuscules, ou tout ce dont vous avez besoin est d'initialiser la première lettre, appelez directement

StringUtils.capitalize(yourString);

Si vous voulez vous assurer que seule la première lettre est en majuscule, comme cela pour un enum, appelez d' toLowerCase()abord et gardez à l'esprit qu'il lancera NullPointerExceptionsi la chaîne d'entrée est nulle.

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

Voici d'autres exemples fournis par apache. c'est gratuit

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

Remarque:

WordUtilsest également inclus dans cette bibliothèque, mais est obsolète. Veuillez ne pas utiliser cela.

Java:

simplement une méthode d'aide pour mettre en majuscule chaque chaîne.

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

Après cela, appelez simplement str = capitalize(str)

Kotlin:

str.capitalize()

Ce que vous voulez faire, c'est probablement ceci:

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

(convertit le premier caractère en majuscule et ajoute le reste de la chaîne d'origine)

En outre, vous créez un lecteur de flux d'entrée, mais ne lisez jamais aucune ligne. Il en namesera toujours ainsi null.

Cela devrait fonctionner:

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)d' Apache Commons .

La solution ci-dessous fonctionnera.

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

Vous ne pouvez pas utiliser toUpperCase () sur un caractère primitif, mais vous pouvez d'abord créer une chaîne entière en majuscules, puis prendre le premier caractère, puis l'ajouter à la sous-chaîne comme indiqué ci-dessus.

Utilisez WordUtils.capitalize(str).

Le plus court aussi:

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

A travaillé pour moi.

Définissez la chaîne en minuscules, puis définissez la première lettre en majuscules comme ceci:

    userName = userName.toLowerCase();

puis de mettre en majuscule la première lettre:

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

substring obtient juste un morceau d'une plus grande chaîne, puis nous les combinons à nouveau.

Qu'en est-il de 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);
    }
}

Utilisez cette méthode utilitaire pour obtenir toutes les premières lettres en majuscule.

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

Vous pouvez également essayer ceci:

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

C'est mieux (optimisé) qu'avec l'utilisation d'une sous-chaîne. (mais ne vous inquiétez pas sur les petites cordes)

Vous pouvez utiliser substring() pour ce faire.

Mais il y a deux cas différents:

Cas 1

Si le Stringfichier en majuscule est destiné à être lisible par l'homme, vous devez également spécifier les paramètres régionaux par défaut:

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

Cas 2

Si le fichier que Stringvous mettez en majuscule est destiné à être lisible par machine, évitez de l'utiliser Locale.getDefault()car la chaîne renvoyée sera incohérente dans différentes régions et dans ce cas, spécifiez toujours les mêmes paramètres régionaux (par exemple, toUpperCase(Locale.ENGLISH)). Cela garantira la cohérence des chaînes que vous utilisez pour le traitement interne, ce qui vous aidera à éviter les bogues difficiles à trouver.

Remarque: Vous n'avez pas besoin de spécifier Locale.getDefault()pour toLowerCase(), car cela se fait automatiquement.

Dans Android Studio

Ajoutez cette dépendance à votre build.gradle (Module: app)

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

Vous pouvez maintenant utiliser

String string = "STRING WITH ALL CAPPS AND SPACES";

string = string.toLowerCase(); // Make all lowercase if you have caps

someTextView.setText(WordUtils.capitalize(string));

si vous utilisez SPRING :

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


    return capitalize(name);

REMARQUE: si vous avez déjà une dépendance Apache Common Lang, envisagez d'utiliser leur StringUtils.capitalize comme d'autres réponses le suggèrent.

MISE EN ŒUVRE: https://github.com/spring-projects/spring-framework/blob/64440a5f04a17b3728234afaa89f57766768decb/spring-core/src/main/java/org/springframework/util/StringUtils.java#L5

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

ÇA MARCHE 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); 

    }

}

C'est juste pour vous montrer que vous ne vous trompiez pas.

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

Remarque: ce n'est pas du tout la meilleure façon de le faire. C'est juste pour montrer à l'OP que cela peut aussi être fait en utilisant charAt(). ;)

Cela fonctionnera

char[] array = value.toCharArray();

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

String result = new String(array);

Vous pouvez utiliser le code suivant:

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

}

essaye celui-là

Ce que fait cette méthode, c'est que, Considérez le mot "bonjour le monde" cette méthode le transforme en "Bonjour le monde" capitalisez le début de chaque mot.

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

    }

Les réponses données concernent la mise en majuscule de la première lettre d'un seul mot. utilisez le code suivant pour mettre une chaîne entière en majuscule.

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

production : This Is A Random String

Si Input est UpperCase, alors utilisez ce qui suit:

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

Si Input est LowerCase, alors utilisez ce qui suit:

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

Jetez un œil à ACL WordUtils.

WordUtils.capitalize ("votre chaîne") == "Votre chaîne"

Comment mettre en majuscule chaque première lettre d'un mot dans une chaîne?

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

Vous pouvez utiliser le code suivant:

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

}

exemple de test avec 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"));
}

Utiliser commons.lang.StringUtilsla meilleure réponse est:

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

Je le trouve génial car il enveloppe la chaîne avec un StringBuffer. Vous pouvez manipuler le StringBuffer comme vous le souhaitez et en utilisant la même instance.

Encore un autre exemple, comment mettre en majuscule la première lettre de l'entrée utilisateur:

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