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
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);
}
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"
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.
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);
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.
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
Travaillé pour moi.
String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);
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.
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));
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.
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);
}
}
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();
}
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(). ;)
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);
}
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?
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();
}
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
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)
Ça va marcher
char[] array = value.toCharArray();
array[0] = Character.toUpperCase(array[0]);
String result = new String(array);
System.out.println(Character.toString(A.charAt(0)).toUpperCase()+A.substring(1));
P.S = a est une chaîne.
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 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
}
}
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;
}
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();
}
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);
}
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;
}
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();
Utilisez la méthode de remplacement.
String newWord = Word.replace(String.valueOf(Word.charAt(0)), String.valueOf(Word.charAt(0)).toUpperCase());
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);
}
}
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();
}
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
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("");
}
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
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.
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();
}
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();
}
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)));
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]+" ");
}
}
}
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()
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
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);
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
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));