Comment capitaliser la première lettre d'une chaîne de caractères en Java?

J'utilise Java pour obtenir une entrée String de l'utilisateur. J'essaie de faire en sorte que la première lettre de cette entrée soit en majuscules.

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

qui a conduit à ces erreurs de compilation:

  • incompatibilité de Type: impossible de convertir de InputStreamReader à BufferedReader

  • ne peut invoquer toUppercase () sur le type primitif char

175
demandé sur Jens Piegsa 2010-10-11 12:23:07

30 réponses

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);
}
269
répondu Rekin 2015-07-07 07:37:31
151
répondu Bozho 2014-03-23 19:03:46

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"

49
répondu Jorgesys 2014-11-05 22:51:36

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);
18
répondu Grodriguez 2010-10-11 08:56:32

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.

15
répondu Fangming 2018-06-17 03:53:50

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.

11
répondu Jijil Kakkadathu 2018-08-03 21:59:35
8
répondu Suresh Kumar 2015-06-16 09:37:40

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.

5
répondu AlexZeCoder 2016-06-03 15:49:07

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.

5
répondu Dassi Orleando 2017-04-12 22:16:28
String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);
5
répondu Aditya Parmar 2017-06-10 10:23:19

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.

4
répondu JDJ 2014-06-15 17:28:36

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));
4
répondu Michael 2015-08-27 13:49:21

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);
    }
}
4
répondu Arpit 2017-01-19 09:04:59

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

3
répondu Adeel Ansari 2015-06-16 08:54:07

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)

2
répondu jerjer 2010-10-11 08:59:42

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

    }
2
répondu Ameen Maheen 2015-07-20 06:58:14

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?

2
répondu Manoj Ekanayaka 2017-05-23 12:10:45
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();
}
2
répondu Doc Brown 2016-12-21 16:30:21
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);
    }
2
répondu Krrish 2018-04-17 11:36:44

Cela fonctionne

char[] array = value.toCharArray();

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

String result = new String(array);
1
répondu Mohamed Abdullah J 2015-07-31 08:52:09

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

}
1
répondu Mulalo Madida 2016-03-11 18:49:40

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;
 }
1
répondu Nooblhu 2016-05-07 09:44:15

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"));
}
1
répondu David Navarro Astudillo 2017-01-11 14:38:48

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
     }
}
1
répondu Deba Mishra 2018-03-16 07:09:04

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;
}
1
répondu Shehroz Khan 2018-08-13 20:24:02

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
0
répondu Delorean 2015-11-23 18:40:20

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

0
répondu Nasser Al kaabi 2015-12-13 18:54:26

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();
    }
0
répondu Raphael Moraes 2016-04-14 19:40:44

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("");
}
0
répondu R. Gordeev 2016-06-18 12:14:37