Comment mettre en majuscule la première lettre d'un mot dans une chaîne en utilisant Java?

Exemples de chaînes

one thousand only
two hundred
twenty
seven

Comment changer le premier caractère d'une chaîne en majuscule et ne pas changer la casse des autres lettres?

Après le changement, cela devrait être:

One thousand only
Two hundred
Twenty
Seven

Remarque: je ne veux pas utiliser l'apache.commons.lang.WordUtils pour ce faire.

Si vous souhaitez uniquement mettre en majuscule la première lettre d'une chaîne nommée inputet laisser le reste tranquille:

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

Maintenant output, vous aurez ce que vous voulez. Vérifiez que votre inputest au moins un caractère bien 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 ça a fini par combiner ce que tout le monde a fini par poster = P.

Le moyen le plus simple est d'utiliser la org.apache.commons.lang.StringUtilsclasse

StringUtils.capitalize(Str);

En outre, il existe org.springframework.util.StringUtilsdans Spring Framework :

StringUtils.capitalize(str);

StringUtils.capitalize(str)

de apache commons-lang .

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

Voilà (j'espère que cela vous 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();
        }
    }

}

Son simple code d'une seule ligne est nécessaire pour cela. si String A = scanner.nextLine(); alors vous devez écrire ceci pour afficher la chaîne avec cette première lettre en majuscule.

System.out.println(A.substring(0, 1).toUpperCase() + A.substring(1));

Et c'est fait maintenant.

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

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

En ajoutant tout ensemble, c'est une bonne idée de couper pour un espace blanc supplémentaire au début de la chaîne. Sinon, .substring (0,1) .toUpperCase essaiera de mettre en majuscule un espace blanc.

    public String capitalizeFirstLetter(String original) {
        if (original == null || original.length() == 0) {
            return original;
        }
        return original.trim().substring(0, 1).toUpperCase() + original.substring(1);
    }

Mon approche fonctionnelle. son caractère majuscule dans la phrase après le blanc dans le paragraphe entier.

Pour capatiliser uniquement le premier caractère du mot, supprimez simplement .split ("")

           b.name.split(" ")
                 .filter { !it.isEmpty() }
                 .map { it.substring(0, 1).toUpperCase() 
                 +it.substring(1).toLowerCase() }
                  .joinToString(" ")

Mise à jour juillet 2019

Actuellement, la fonction de bibliothèque la plus à jour pour ce 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>

Même pour du code "simple", j'utiliserais des bibliothèques. Le problème n'est pas le code en soi, mais les cas de test déjà existants couvrant des cas exceptionnels. Cela pourrait être nulldes chaînes vides, des chaînes dans d'autres langues.

La partie manipulation de mots a été retirée de Apache Commons Lang. Il est maintenant placé dans Apache Commons Text . Obtenez-le via https://search.maven.org/artifact/org.apache.commons/commons-text .

Vous pouvez utiliser WordUtils.capitalize (String str) à partir d'Apache Commons Text. Il est plus puissant que vous ne l'aviez demandé. Il peut également capitaliser le fulle (par exemple, la fixation "oNe tousand only").

Puisqu'il fonctionne sur du texte complet, il faut lui dire de ne mettre en majuscule que le premier mot.

WordUtils.capitalize("one thousand only", new char[0]);

Classe JUnit complète pour permettre de jouer avec la fonctionnalité:

package io.github.koppor;

import org.apache.commons.text.WordUtils;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class AppTest {

  @Test
  void test() {
    assertEquals("One thousand only", WordUtils.capitalize("one thousand only", new char[0]));
  }

}

si vous souhaitez uniquement mettre en majuscule la première lettre, le code ci-dessous peut être utilisé

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

En fait, vous obtiendrez les meilleures performances si vous évitez l' +opérateur et l'utilisation concat()dans ce cas. C'est la meilleure option pour fusionner seulement 2 chaînes (pas si bon pour de nombreuses chaînes cependant). Dans ce cas, le code ressemblerait à ceci:

String output = input.substring(0, 1).toUpperCase().concat(input.substring(1));

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

Étant donné la inputchaîne:

Character.toUpperCase(input.charAt(0)) + input.substring(1).toLowerCase()

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

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

Je voudrais ajouter une vérification NULL et 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;
        }
    }

Production:

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]

Ce qui suit vous donnera la même sortie cohérente quelle que soit la valeur de votre chaîne d'entrée:

if(StringUtils.isNotBlank(inputString)) {
    inputString = StringUtils.capitalize(inputString.toLowerCase());
}

1. Utilisation de la substring()méthode de String

public static String capitalize(String str) {
    if(str== null || str.isEmpty()) {
        return str;
    }

    return str.substring(0, 1).toUpperCase() + str.substring(1);
}

Maintenant, appelez simplement la capitalize()méthode pour convertir la première lettre d'une chaîne en majuscules:

System.out.println(capitalize("stackoverflow")); // Stackoverflow
System.out.println(capitalize("heLLo")); // HeLLo
System.out.println(capitalize(null)); // null

2. Apache Commons Lang

La StringUtilsclasse de Commons Lang fournit la capitalize()méthode qui peut également être utilisée à cette fin:

System.out.println(StringUtils.capitalize("apache commons")); // Apache commons
System.out.println(StringUtils.capitalize("heLLO")); // HeLLO
System.out.println(StringUtils.uncapitalize(null)); // null

Ajoutez la dépendance suivante à votre pom.xmlfichier (pour Maven uniquement):

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>

Voici un article qui explique ces deux approches en détail.

class Test {
     public static void main(String[] args) {
        String newString="";
        String test="Hii lets cheCk for BEING String";  
        String[] splitString = test.split(" ");
        for(int i=0; i<splitString.length; i++){
            newString= newString+ splitString[i].substring(0,1).toUpperCase() 
                    + splitString[i].substring(1,splitString[i].length()).toLowerCase()+" ";
        }
        System.out.println("the new String is "+newString);
    }
 }