web-dev-qa-db-fra.com

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

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

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:

  • Type incompatible: impossible de convertir InputStreamReader en BufferedReader

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

199
sumithra
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);
}
293
Rekin
160
Bozho

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"

58
Elenasys

Utilisez la bibliothèque commune d'Apache. Libérez votre cerveau de ces choses et évitez les exceptions Null Pointer & Index Out of Bound

Étape 1:

Importer la bibliothèque de lang commune d'Apache en le mettant dans des dépendances build.gradle

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

Étape 2:

Si vous êtes sûr que votre chaîne est en minuscule ou s'il vous suffit 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 c'est le cas pour une variable enum, appelez d'abord toLowerCase() et gardez à l'esprit qu'elle 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 plaît ne pas utilisez cela.

28
Fangming

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)

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);
19
Grodriguez
14
Zaki

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 commencer par définir String en majuscule, puis prendre le premier caractère, puis l'ajouter à la sous-chaîne, comme indiqué ci-dessus.

11
Jijil Kakkadathu
8
Suresh Kumar

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

Travaillé pour moi.

5
Dassi Orleando
String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);
5
Aditya Parmar

Définissez la chaîne en minuscule, puis définissez la première lettre en haut de la manière suivante:

    userName = userName.toLowerCase();

puis pour capitaliser la première lettre:

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

la sous-chaîne ne fait que prendre un morceau d'une chaîne plus grande, puis nous les combinons ensemble.

5
AlexZeCoder

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
Michael

Vous pouvez utiliser substring() pour le faire. 

Mais il y a deux cas différents:

Cas 1

Si le String que vous mettez en majuscule est 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 String que vous mettez en majuscule est 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 la cohérence des chaînes que vous utilisez pour le traitement interne, ce qui vous aidera à éviter les bogues difficiles à trouver.

Remarque: Il n'est pas nécessaire de spécifier Locale.getDefault() pour toLowerCase(), car cela se fait automatiquement.

4
JDJ

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

essaye celui-là

Ce que fait cette méthode est que, considérons le mot "bonjour le monde" cette méthode le transforme en "Bonjour le monde" capitalise 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();

    }
3
Ameen Maheen

Ceci 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. Ceci est juste pour montrer au PO que cela peut être fait en utilisant également charAt(). ;)

3
Adeel Ansari
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
Krrish

Jetez un coup d'œil à ACL WordUtils.

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

Comment mettre en majuscule chaque première lettre de Word dans une chaîne?

2
Manoj Ekanayaka
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
Doc Brown

Les réponses données ne servent qu'à mettre en majuscule la première lettre d'un mot. utilisez le code suivant pour mettre toute une chaîne 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());
}

sortie: This Is A Random String

2
Vimukthi_R

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

2
jerjer

Ça va marcher

char[] array = value.toCharArray();

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

String result = new String(array);
2
Mohamed Abdullah J
System.out.println(Character.toString(A.charAt(0)).toUpperCase()+A.substring(1));

P.S = a est une chaîne.

1
Germa Vinsmoke

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

Pour capitaliser le premier caractère de chaque mot dans une chaîne,

tout d'abord, vous devez obtenir chaque mot de cette chaîne et pour cette chaîne scindée où il y a de l'espace en utilisant la méthode de scission ci-dessous, puis 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 (), capitalisez le premier caractère et ajoutez les caractères restants 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
Dev d

Le code que j'ai posté supprimera le trait de soulignement (_) et les espaces supplémentaires de String, ainsi que la première lettre de chaque nouveau mot dans String.

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
Shehroz

Une des réponses était correcte à 95%, mais la solution de mon unité Test @Ameen Maheen était presque parfaite. Sauf qu'avant que l'entrée soit convertie en tableau String, vous devez rogner l'entrée. Donc le parfait:

private String convertStringToName(String name) {
        name = name.trim();
        String[] words = name.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();
    }
1
crix

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
Mulalo Madida

La plupart des réponses étant très utiles, je les ai utilisées pour créer une méthode permettant de transformer une 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;
 }
1
Nooblhu

Une approche.

String input = "someТекст$T%$4čřЭ"; //Enter your text.
if (input == null || input.isEmpty()) {
    return "";
}

char [] chars = input.toCharArray();
chars[0] = chars[0].toUpperCase();
String res = new String(chars);
return res;

L'inconvénient de cette méthode est que si inputString est long, vous aurez trois objets de cette longueur. Le même que toi

String s1 = input.substring(1).toUpperCase();
String s2 = input.substring(1, lenght);
String res = s1 + s2;

Ou même

//check if not null.
StringBuilder buf = new StringBuilder(input);
char ch = buf.getCharAt(0).toUpperCase();
buf.setCharAt(0, ch);
return buf.toString();
0
Yan Khonski

Utilisez la méthode de remplacement.

String newWord = Word.replace(String.valueOf(Word.charAt(0)), String.valueOf(Word.charAt(0)).toUpperCase());
0
Engine
public void capitalizeFirstLetter(JTextField textField) {

    try {

        if (!textField.getText().isEmpty()) {
            StringBuilder b = new StringBuilder(textField.getText());
            int i = 0;
            do {
                b.replace(i, i + 1, b.substring(i, i + 1).toUpperCase());
                i = b.indexOf(" ", i) + 1;
            } while (i > 0 && i < b.length());
            textField.setText(b.toString());
        }

    } catch (Exception e) {
        e.printStackTrace();
        JOptionPane.showMessageDialog(null, e, "Error", JOptionPane.ERROR_MESSAGE);
    }
}
0
Suresh

Ce code permet de capitaliser chaque mot dans le texte!

public String capitalizeText(String name) {
    String[] s = name.trim().toLowerCase().split("\\s+");
    name = "";
    for (String i : s){
        if(i.equals("")) return name; // or return anything you want
        name+= i.substring(0, 1).toUpperCase() + i.substring(1) + " "; // uppercase first char in words
    }
    return name.trim();
}
0
An Van Nguyen

Vous pouvez utiliser la classe WordUtils.

Supposons que votre chaîne est "adresse actuelle" puis utilisez 

**** strong textWordutils.capitaliz (String); sortie: adresse actuelle

Voir: http://commons.Apache.org/proper/commons-lang/apidocs/org/Apache/commons/lang3/text/WordUtils.html

0
SANDEEP KIRWAI

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("");
}
0
R. Gordeev

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 ça aide Bonne chance 

0
Nasser Al kaabi

Dans commons.lang.StringUtils, la 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 brillant car il enveloppe la chaîne avec un StringBuffer. Vous pouvez manipuler le StringBuffer à votre guise en utilisant la même instance.

0
velocity

Je viens de retravailler le code Jorgesys et nous avons ajouté peu de vérifications en raison de quelques cas liés à la longueur de chaîne. Ne faites pas pour la vérification de référence nulle dans mon cas.

 public static String capitalizeFirstLetter(@NonNull String customText){
        int count = customText.length();
        if (count == 0) {
            return customText;
        }
        if (count == 1) {
            return customText.toUpperCase();
        }
        return customText.substring(0, 1).toUpperCase() + customText.substring(1).toLowerCase();
    }
0
Ruslan Podurets

La réponse d'Ameen Mahheen est bonne, mais si nous avons une chaîne à 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();
    }
0
Raphael Moraes

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

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)));
0
Aleksey Bykov
class CapitalizeWords
{
    public static void main(String[] args) 
    {
        String input ="welcome to kashmiri geeks...";

        System.out.println(input);

        String[] str = input.split(" ");

        for(int i=0; i< str.length; i++)
        {
            str[i] = (str[i]).substring(0,1).toUpperCase() + (str[i]).substring(1);
        }

        for(int i=0;i<str.length;i++)
        {
            System.out.print(str[i]+" ");
        }


    }
}
0
Maahi bhat

Pour les utilisateurs de Java:

simplement une extension pour capitaliser chaque chaîne.

public static capitalize(String str)
{
    return this.substring(0, 1).toUpperCase() + this.substring(1)
}

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

Pour les utilisateurs de Kotlin, appelez simplement:

str.capitalize()
0

L'exemple suivant met également les mots 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
Delorean

Si Input est UpperCase, utilisez ensuite:

str_strstr (0, 1) .toUpperCase () + str_strstr (1).

Si Input est LowerCase, utilisez ensuite:

strstring (0, 1) .toUpperCase () + strstrstr (1);

0
Raj Kumar
import Java.util.*;
public class Program
{
    public static void main(String[] args) 
      {
        Scanner sc=new Scanner(System.in);
        String s1=sc.nextLine();
        String[] s2=s1.split(" ");//***split text into words***
        ArrayList<String> l = new ArrayList<String>();//***list***
        for(String w: s2)
        l.add(w.substring(0,1).toUpperCase()+w.substring(1)); 
        //***converting 1st letter to capital and adding to list***
        StringBuilder sb = new StringBuilder();//***i used StringBuilder to convert words to text*** 
        for (String s : l)
          {
             sb.append(s);
             sb.append(" ");
          }
      System.out.println(sb.toString());//***to print output***
      }
}

j'ai utilisé la fonction split pour diviser la chaîne en mots, puis à nouveau j'ai pris la liste pour obtenir la première lettre en majuscule dans ces mots, puis j'ai pris le constructeur de chaînes pour imprimer la sortie au format chaîne avec des espaces

0
Sindhu Adapa
String s = "first second third fourth";

        int j = 0;
        for (int i = 0; i < s.length(); i++) {

            if ((s.substring(j, i).endsWith(" "))) {

                String s2 = s.substring(j, i);
                System.out.println(Character.toUpperCase(s.charAt(j))+s2.substring(1));
                j = i;
            }
        }
        System.out.println(Character.toUpperCase(s.charAt(j))+s.substring(j+1));
0
emre hamurcu