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(..) à partir 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 name est "Stackoverflow"

Ce que vous voulez faire 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)

De plus, vous créez un lecteur de flux d'entrée, mais ne lisez jamais aucune ligne. Donc name sera toujours null.

Cela devrait fonctionner:

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

Utilisez la bibliothèque commune d'Apache. Libérez votre cerveau de ces choses et évitez le Pointeur Nul et l'Index Hors Des Exceptions Liées

Étape 1:

Importez la bibliothèque common lang d'apache en la mettant dans build.gradle dependencies

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

Étape 2:

Si vous êtes sûr que votre chaîne est toute 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 pour un enum, appelez d'abord toLowerCase() et gardez à l'esprit qu'il lancera NullPointerException si 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 sans exception

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

Remarque:

WordUtils est également inclus dans cette bibliothèque, mais est obsolète. S'il vous plait ne l'utilisez pas.

WordUtils.capitalize(java.lang.String) à partir de 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 le caractère primitif , mais vous pouvez d'abord faire une chaîne entière en majuscules, puis prendre le premier caractère, puis ajouter à la sous-chaîne comme indiqué ci-dessus.

Utiliser WordUtils.capitalize(str).

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

    userName = userName.toLowerCase();

, Puis pour mettre en majuscule la première lettre:

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

La sous-chaîne obtient juste un morceau d'une chaîne plus grande, puis nous les combinons ensemble.

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.

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

, Vous pouvez utiliser substring() pour ce faire.

, Mais il y a deux cas différents:

Cas 1

Si le String que vous mettez en majuscule est censé ê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 String que vous mettez en majuscule est censé être lisible par machine, évitez d'utiliser Locale.getDefault() car la chaîne renvoyée sera incohérente entre 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 que les chaînes que vous utilisez pour le traitement interne sont cohérentes, ce qui vous aidera à éviter les bogues difficiles à trouver.

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

Dans Android Studio

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

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

Maintenant, vous pouvez utiliser

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

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

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

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

C'est juste pour vous montrer que vous n'aviez pas tort.

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 également être fait en utilisant charAt(). ;)

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 de la sous-chaîne. (mais ne vous inquiétez pas sur une petite chaîne)

Essayez celui-ci

Ce que fait cette méthode, c'est que considérer le travail "hello world" cette méthode le transforme en "Hello World" en majuscule 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();

    }

Jetez un oeil à ACL Worddutils.

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

Comment majuscules chaque première lettre de 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();
}

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

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

}

Beaucoup de réponses sont très utiles, donc je les ai utilisées pour créer une méthode pour transformer n'importe quelle chaîne en titre (premier caractère en majuscule):

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

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

Pour mettre en majuscule le premier caractère de chaque mot d'une chaîne ,

Vous devez d'abord obtenir chaque mot de cette chaîne et pour cette chaîne divisée où n'importe quel espace est là en utilisant la méthode split comme ci-dessous et stocker chaque mot dans un tableau. Créez ensuite une chaîne vide. Après cela, en utilisant la méthode substring (), obtenez le premier caractère et le caractère restant du mot correspondant et stockez-les dans deux variables différentes.

Ensuite, en utilisant la méthode toUpperCase (), mettez en majuscule le premier caractère et ajoutez les caractères remaianing comme ci-dessous à cette chaîne vide.

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

Le code que j'ai posté supprimera le symbole de soulignement(_) et les espaces supplémentaires de la chaîne et mettra également en majuscule la première lettre de chaque nouveau mot dans la chaîne

private String capitalize(String txt){ 
  List<String> finalTxt=new ArrayList<>();

  if(txt.contains("_")){
       txt=txt.replace("_"," ");
  }

  if(txt.contains(" ") && txt.length()>1){
       String[] tSS=txt.split(" ");
       for(String tSSV:tSS){ finalTxt.add(capitalize(tSSV)); }  
  }

  if(finalTxt.size()>0){
       txt="";
       for(String s:finalTxt){ txt+=s+" "; }
  }

  if(txt.endsWith(" ") && txt.length()>1){
       txt=txt.substring(0, (txt.length()-1));
       return txt;
  }

  txt = txt.substring(0,1).toUpperCase() + txt.substring(1).toLowerCase();
  return txt;
}

L'exemple suivant met également en majuscules les mots après des caractères spéciaux tels que [/- ]

  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

Merci j'ai lu certains des commentaires et je suis venu avec ce qui suit

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

J'espère que cela aide bonne chance

La réponse d'Ameen Mahheen est bonne mais si nous avons une chaîne avec un double espace, comme "hello world" alors sb.append obtient l'exception IndexOutOfBounds. La bonne chose à faire est de tester avant cette ligne, en faisant:

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

Vous pouvez essayer ceci

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