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 capitaliser 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 char en majuscule et ajoute le reste de la chaîne originale)

en outre, vous créez un lecteur de flux d'entrée, mais ne lisez jamais aucune ligne. Ainsi 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 étoffes et évitez le pointeur nul et L'Index hors des Exceptions liées

Étape 1:

importer la bibliothèque Lang commune d'apache en mettant ceci dans build.gradle dépendances

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

Étape 2:

si vous êtes sûr que votre chaîne est en minuscules, ou tout ce dont vous avez besoin est de initialiser la première lettre, appeler directement

StringUtils.capitalize(yourString);

si vous voulez vous assurer que seule la première lettre est en majuscules, comme faire ceci pour un enum , appelez toLowerCase() d'abord et gardez à l'esprit qu'il lancera NullPointerException si la chaîne de caractères est nulle.

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

Voici d'autres échantillons fournis par apache. c'est l'exception libre

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

Note:

WordUtils est aussi inclus dans cette bibliothèque, mais est déprécié. S'il vous plaît ne pas utilisez cela.

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

ci-dessous la solution 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 char primitif , mais vous pouvez faire la chaîne entière au majuscule d'abord puis prendre le premier char, puis l'ajouter à la chaîne comme montré ci-dessus.

Utilisation WordUtils.capitalize(str) .

règle la chaîne en minuscules, puis règle la première lettre en majuscules comme ceci:

    userName = userName.toLowerCase();

puis capitaliser la première lettre:

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

sous-chaîne est une pièce d'une grande chaîne, nous sommes les combiner ensemble.

plus court aussi:

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

travaillait 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 la majuscule String que vous utilisez est destinée à être lisible par l'humain, vous devez également spécifier la locale par défaut:

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

Cas 2

si le String que vous capitalisez est censé être lisible par la machine, évitez d'utiliser Locale.getDefault() car la chaîne de caractères renvoyée sera incohérente entre les différentes régions, et dans ce cas précisez toujours la même locale (par exemple, toUpperCase(Locale.ENGLISH) ). Cela vous permettra de vous assurer que les chaînes que vous utilisez pour le traitement interne sont cohérentes, ce qui vous aidera à éviter les bogues difficiles à trouver.

Note: il n'est pas nécessaire 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'
    ...
}

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.capitalissiblement () ?

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'étiez pas de mal.

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

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

vous pouvez aussi 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 substrats. (mais ne vous inquiétez pas sur la petite chaîne)

essayer celui-ci

Que cette méthode n'est que de considérer le travail "hello world" cette méthode transformer en "Hello World" capitaliser 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();

    }

Avoir un coup d'oeil à ACL WordUtils.

Worddutils.capitaliser ("votre chaîne") = = "votre chaîne "

Comment majuscules chaque première lettre d'un mot dans une chaîne de caractères?

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 fonctionne

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 de caractères en un titre (premier caractère en majuscules):

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 d'essai 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 capitaliser le premier caractère de chaque mot d'une chaîne,

tout d'abord, vous devez obtenir chaque mot de cette chaîne et pour cette chaîne dédoublée où n'importe quel espace est là en utilisant la méthode de dédoublement comme ci-dessous et stocker chaque mot dans un tableau. Puis créer une chaîne vide. Après cela, en utilisant la méthode substring (), récupérez le premier caractère et le caractère restant du mot correspondant et stockez-les dans deux variables différentes.

puis en utilisant toUpperCase() méthode capitaliser le premier caractère et ajouter les caractères de 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 corde et aussi il capitalisera la première lettre de chaque nouveau mot dans la corde

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

dans l'exemple qui suit, les mots sont aussi majuscules après les 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 le suivant

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 ses aides bonne chance

la réponse d'Ameen Mahheen est bonne mais si nous avons une corde avec double espace, comme "hello world" alors sb.l'annexe 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 ce

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