Comment capitaliser la première lettre de Word dans une chaîne en utilisant Java?
Exemple de chaînes
one thousand only
two hundred
twenty
seven
Comment changer le premier caractère d'une chaîne en majuscule sans changer la casse des autres lettres?
Après le changement, cela devrait être:
One thousand only
Two hundred
Twenty
Seven
Remarque: je ne souhaite pas utiliser Apache.commons.lang.WordUtils à cette fin.
Si vous voulez seulement mettre en majuscule la première lettre d'une chaîne nommée input et laisser le reste tranquille:
String output = input.substring(0, 1).toUpperCase() + input.substring(1);
Maintenant, output aura ce que vous voulez. Vérifiez que votre input est d'au moins un caractère avant de l'utiliser, sinon vous obtiendrez une exception.
public String capitalizeFirstLetter(String original) {
if (original == null || original.length() == 0) {
return original;
}
return original.substring(0, 1).toUpperCase() + original.substring(1);
}
Juste ... une solution complète, je vois que c'est en quelque sorte juste de combiner ce que tout le monde a fini par poster = P.
De plus, il existe org.springframework.util.StringUtils dans Spring Framework :
StringUtils.capitalize(str);
String sentence = "ToDAY WeAthEr GREat";
public static String upperCaseWords(String sentence) {
String words[] = sentence.replaceAll("\\s+", " ").trim().split(" ");
String newSentence = "";
for (String Word : words) {
for (int i = 0; i < Word.length(); i++)
newSentence = newSentence + ((i == 0) ? Word.substring(i, i + 1).toUpperCase():
(i != Word.length() - 1) ? Word.substring(i, i + 1).toLowerCase() : Word.substring(i, i + 1).toLowerCase().toLowerCase() + " ");
}
return newSentence;
}
//Today Weather Great
String s=t.getText().trim();
int l=s.length();
char c=Character.toUpperCase(s.charAt(0));
s=c+s.substring(1);
for(int i=1; i<l; i++)
{
if(s.charAt(i)==' ')
{
c=Character.toUpperCase(s.charAt(i+1));
s=s.substring(0, i) + c + s.substring(i+2);
}
}
t.setText(s);
Ici vous allez (espérons que cela vous en donne l'idée):
/*************************************************************************
* Compilation: javac Capitalize.Java
* Execution: Java Capitalize < input.txt
*
* Read in a sequence of words from standard input and capitalize each
* one (make first letter uppercase; make rest lowercase).
*
* % Java Capitalize
* now is the time for all good
* Now Is The Time For All Good
* to be or not to be that is the question
* To Be Or Not To Be That Is The Question
*
* Remark: replace sequence of whitespace with a single space.
*
*************************************************************************/
public class Capitalize {
public static String capitalize(String s) {
if (s.length() == 0) return s;
return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
}
public static void main(String[] args) {
while (!StdIn.isEmpty()) {
String line = StdIn.readLine();
String[] words = line.split("\\s");
for (String s : words) {
StdOut.print(capitalize(s) + " ");
}
StdOut.println();
}
}
}
Exemple d'utilisation de la classe StringTokenizer:
String st = " hello all students";
String st1;
char f;
String fs="";
StringTokenizer a= new StringTokenizer(st);
while(a.hasMoreTokens()){
st1=a.nextToken();
f=Character.toUpperCase(st1.charAt(0));
fs+=f+ st1.substring(1);
System.out.println(fs);
}
Mise à jour juillet 2019
Actuellement, la fonction de bibliothèque la plus récente pour le faire est contenue dans org.Apache.commons.lang3.StringUtils
import org.Apache.commons.lang3.StringUtils;
StringUtils.capitalize(myString);
Si vous utilisez Maven, importez la dépendance dans votre pom.xml:
<dependency>
<groupId>org.Apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.9</version>
</dependency>
En additionnant tout, c'est une bonne idée de couper pour un espace supplémentaire au début de la chaîne. Sinon, .substring (0,1) .toUpperCase tentera de mettre un espace en majuscule.
public String capitalizeFirstLetter(String original) {
if (original == null || original.length() == 0) {
return original;
}
return original.trim().substring(0, 1).toUpperCase() + original.substring(1);
}
public static String capitalize(String str){
String[] inputWords = str.split(" ");
String outputWords = "";
for (String Word : inputWords){
if (!Word.isEmpty()){
outputWords = outputWords + " "+StringUtils.capitalize(Word);
}
}
return outputWords;
}
Vous pouvez essayer le code suivant:
public string capitalize(str) {
String[] array = str.split(" ");
String newStr;
for(int i = 0; i < array.length; i++) {
newStr += array[i].substring(0,1).toUpperCase() + array[i].substring(1) + " ";
}
return newStr.trim();
}
Solution avec StringBuilder:
value = new StringBuilder()
.append(value.substring(0, 1).toUpperCase())
.append(value.substring(1))
.toString();
.. basé sur les réponses précédentes
Je voudrais ajouter un contrôle NULL et une exception IndexOutOfBoundsException sur la réponse acceptée.
String output = input.substring(0, 1).toUpperCase() + input.substring(1);
Code Java:
class Main {
public static void main(String[] args) {
System.out.println("Capitalize first letter ");
System.out.println("Normal check #1 : ["+ captializeFirstLetter("one thousand only")+"]");
System.out.println("Normal check #2 : ["+ captializeFirstLetter("two hundred")+"]");
System.out.println("Normal check #3 : ["+ captializeFirstLetter("twenty")+"]");
System.out.println("Normal check #4 : ["+ captializeFirstLetter("seven")+"]");
System.out.println("Single letter check : ["+captializeFirstLetter("a")+"]");
System.out.println("IndexOutOfBound check : ["+ captializeFirstLetter("")+"]");
System.out.println("Null Check : ["+ captializeFirstLetter(null)+"]");
}
static String captializeFirstLetter(String input){
if(input!=null && input.length() >0){
input = input.substring(0, 1).toUpperCase() + input.substring(1);
}
return input;
}
}
Sortie:
Normal check #1 : [One thousand only]
Normal check #2 : [Two hundred]
Normal check #3 : [Twenty]
Normal check #4 : [Seven]
Single letter check : [A]
IndexOutOfBound check : []
Null Check : [null]
Utilisez ceci:
char[] chars = {Character.toUpperCase(A.charAt(0)),
Character.toUpperCase(B.charAt(0))};
String a1 = chars[0] + A.substring(1);
String b1 = chars[1] + B.substring(1);
Ce qui suit vous donnera la même sortie cohérente quelle que soit la valeur de votre inputString:
if(StringUtils.isNotBlank(inputString)) {
inputString = StringUtils.capitalize(inputString.toLowerCase());
}
Mon approche fonctionnelle. sa capstilise le premier caractère de la phrase après le blanc du paragraphe entier.
Pour capatiliser uniquement le premier caractère du mot, supprimez split ("")
b.name.split(" ")
.filter { !it.isEmpty() }
.map { it.substring(0, 1).toUpperCase()
+it.substring(1).toLowerCase() }
.joinToString(" ")
Étant donné la chaîne input:
Character.toUpperCase(input.charAt(0)) + input.substring(1).toLowerCase()