Comment mettre en majuscule le premier caractère de chaque mot d'une chaîne


421

Existe-t-il une fonction intégrée à Java qui met en majuscule le premier caractère de chaque mot d'une chaîne et n'affecte pas les autres?

Exemples:

  • jon skeet -> Jon Skeet
  • miles o'Brien-> Miles O'Brien(B reste capital, cela exclut le titre)
  • old mcdonald-> Old Mcdonald*

* ( Old McDonaldserait trouver aussi, mais je ne m'attends pas à ce que ce soit intelligent.)

Un rapide coup d'œil à la documentation de la chaîne Java révèle seulement toUpperCase()et toLowerCase(), qui bien sûr ne fournissent pas le comportement souhaité. Naturellement, les résultats de Google sont dominés par ces deux fonctions. Cela ressemble à une roue qui doit déjà avoir été inventée, donc ça ne fait pas de mal de demander donc je peux l'utiliser à l'avenir.


18
Et alors old mcdonald? Cela devrait-il devenir Old McDonald?
Bart Kiers

2
Je ne m'attends pas à ce que la fonction soit aussi intelligente. (Bien que si vous en avez un, je serais heureux de le voir.) Juste en haut de la première lettre après un espace blanc, mais ignorez le reste.
WillfulWizard


1
De toute façon, vous ne seriez pas en mesure de trouver un algorithme qui gère correctement la capitalisation des noms ... tant qu'il y a des paires de noms, qui peuvent être correctes pour une personne donnée, comme MacDonald et Macdonald, la fonction serait n'ont aucun moyen de savoir ce qui était correct. Il vaut mieux faire ce que vous avez fait, bien que vous vous trompiez toujours de noms (comme von Neumann).
Dave DuPlantis

Essayez Burger King ...
Magno C

Réponses:


732

WordUtils.capitalize(str)(d'après apache commons-text )

(Remarque: si vous devez "fOO BAr"devenir "Foo Bar", utilisez capitalizeFully(..)plutôt)


5
Je pense que vous voulez dire WordUtils.capitalize (str). Voir API pour plus de détails.
Hans Doggen

84
Garder ma philosophie de toujours voter pour les réponses qui se réfèrent aux bibliothèques communes.
Ravi Wallau

11
Pour remplacer la non-première lettre par les mots en minuscules, utilisez capitalizeFully (str).
Umesh Rajbhandari

5
Cette solution est-elle vraiment correcte ? ce n'est pas à mon avis! Si vous voulez capitaliser "LAMborghini", vous voulez "Lamborghini" à la fin. La WordUtils.capitalizeFully(str)solution aussi.
basZero

3
@BasZero c'est la bonne réponse à la question posée. Je vais inclure la version Fully en tant que commentaire.
Bozho

229

Si vous ne vous inquiétez que de la première lettre du premier mot en majuscule:

private String capitalize(final String line) {
   return Character.toUpperCase(line.charAt(0)) + line.substring(1);
}

3
cela ne change que la première lettre du premier mot
Chrizzz

28
En effet, c'était mon intention.
Nick Bolton

13
@nbolton - Mais il ignore explicitement l'intention de la question, et échoue pour les cas mêmes donnés dans cet exemple - et il ajoute peu ou rien aux réponses données précédemment!
David Manheim

17
Ce morceau de code n'est pas protégé contre les pannes! Imaginez lineêtre nul ou avoir une longueur <2.
stk

1
encore, retournez Character.toUpperCase (word.charAt (0)) + word.substring (1) .toLowerCase ()
Sauf le

72

La méthode suivante convertit toutes les lettres en majuscules / minuscules, selon leur position à proximité d'un espace ou d'autres caractères spéciaux.

public static String capitalizeString(String string) {
  char[] chars = string.toLowerCase().toCharArray();
  boolean found = false;
  for (int i = 0; i < chars.length; i++) {
    if (!found && Character.isLetter(chars[i])) {
      chars[i] = Character.toUpperCase(chars[i]);
      found = true;
    } else if (Character.isWhitespace(chars[i]) || chars[i]=='.' || chars[i]=='\'') { // You can add other chars here
      found = false;
    }
  }
  return String.valueOf(chars);
}

J'améliorer et simplifier les conditions de boucle: if(Character.isLetter(chars[i])) { if(!found) { chars[i] = Character.toUpperCase(chars[i]); } found = true; } else { found = false; }.
danseur

@bancer, avec votre exemple, vous ne pouvez pas contrôler quels caractères ne seront pas suivis d'une lettre majuscule.
True Soft

@TrueSoft, je ne vous comprends pas. Pourquoi avez-vous besoin de contrôler les caractères qui suivent les majuscules? Si j'ai bien compris, il est important que le caractère précédent ne soit pas une lettre et mon exemple le garantit. Remplacez simplement votre bloc if-else-if par mon bloc if-else et lancez un test.
danseur

@TrueSoft, pour plus de clarté , je renommer foundà previousCharIsLetter.
danseur

9
J'aime avoir des réponses qui n'utilisent pas la bibliothèque commune, car de temps en temps vous ne pouvez pas l'utiliser.
Heckman

39

Essayez cette méthode très simple

example givenString = "ram est bon garçon"

public static String toTitleCase(String givenString) {
    String[] arr = givenString.split(" ");
    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < arr.length; i++) {
        sb.append(Character.toUpperCase(arr[i].charAt(0)))
            .append(arr[i].substring(1)).append(" ");
    }          
    return sb.toString().trim();
}  

La sortie sera: Ram Is Good Boy


1
ce code a provoqué le plantage de notre serveur: java.lang.StringIndexOutOfBoundsException: index de chaîne hors plage: 0
Chrizzz

32
@Chrizzz donc ne validez pas le code que vous n'avez pas testé ... Si vous fournissez une chaîne vide, elle plante. C'est ta faute, pas celle de Neelam.
Reinherd

1
S'il y a un espace à la fin, il se bloque, puis j'ai ajouté trim () en premier et divisé la chaîne avec de l'espace. Cela a parfaitement fonctionné
Hanuman

Au cas où quelqu'un chercherait sa version Kotlin, le voici: stackoverflow.com/a/55390188/1708390
Bugs Happen

16

J'ai écrit une petite classe pour mettre en majuscule tous les mots d'une chaîne.

Facultatif multiple delimiters, chacun avec son comportement (capitaliser avant, après ou les deux, pour gérer des cas comme O'Brian);

En option Locale;

Ne rompt pas avec Surrogate Pairs.

DÉMO EN DIRECT

Production:

====================================
 SIMPLE USAGE
====================================
Source: cApItAlIzE this string after WHITE SPACES
Output: Capitalize This String After White Spaces

====================================
 SINGLE CUSTOM-DELIMITER USAGE
====================================
Source: capitalize this string ONLY before'and''after'''APEX
Output: Capitalize this string only beforE'AnD''AfteR'''Apex

====================================
 MULTIPLE CUSTOM-DELIMITER USAGE
====================================
Source: capitalize this string AFTER SPACES, BEFORE'APEX, and #AFTER AND BEFORE# NUMBER SIGN (#)
Output: Capitalize This String After Spaces, BeforE'apex, And #After And BeforE# Number Sign (#)

====================================
 SIMPLE USAGE WITH CUSTOM LOCALE
====================================
Source: Uniforming the first and last vowels (different kind of 'i's) of the Turkish word D[İ]YARBAK[I]R (DİYARBAKIR) 
Output: Uniforming The First And Last Vowels (different Kind Of 'i's) Of The Turkish Word D[i]yarbak[i]r (diyarbakir) 

====================================
 SIMPLE USAGE WITH A SURROGATE PAIR 
====================================
Source: ab 𐐂c de à
Output: Ab 𐐪c De À

Remarque: la première lettre sera toujours en majuscule (modifiez la source si vous ne le souhaitez pas).

Partagez vos commentaires et aidez-moi à trouver des bugs ou à améliorer le code ...

Code:

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;

public class WordsCapitalizer {

    public static String capitalizeEveryWord(String source) {
        return capitalizeEveryWord(source,null,null);
    }

    public static String capitalizeEveryWord(String source, Locale locale) {
        return capitalizeEveryWord(source,null,locale);
    }

    public static String capitalizeEveryWord(String source, List<Delimiter> delimiters, Locale locale) {
        char[] chars; 

        if (delimiters == null || delimiters.size() == 0)
            delimiters = getDefaultDelimiters();                

        // If Locale specified, i18n toLowerCase is executed, to handle specific behaviors (eg. Turkish dotted and dotless 'i')
        if (locale!=null)
            chars = source.toLowerCase(locale).toCharArray();
        else 
            chars = source.toLowerCase().toCharArray();

        // First charachter ALWAYS capitalized, if it is a Letter.
        if (chars.length>0 && Character.isLetter(chars[0]) && !isSurrogate(chars[0])){
            chars[0] = Character.toUpperCase(chars[0]);
        }

        for (int i = 0; i < chars.length; i++) {
            if (!isSurrogate(chars[i]) && !Character.isLetter(chars[i])) {
                // Current char is not a Letter; gonna check if it is a delimitrer.
                for (Delimiter delimiter : delimiters){
                    if (delimiter.getDelimiter()==chars[i]){
                        // Delimiter found, applying rules...                       
                        if (delimiter.capitalizeBefore() && i>0 
                            && Character.isLetter(chars[i-1]) && !isSurrogate(chars[i-1]))
                        {   // previous character is a Letter and I have to capitalize it
                            chars[i-1] = Character.toUpperCase(chars[i-1]);
                        }
                        if (delimiter.capitalizeAfter() && i<chars.length-1 
                            && Character.isLetter(chars[i+1]) && !isSurrogate(chars[i+1]))
                        {   // next character is a Letter and I have to capitalize it
                            chars[i+1] = Character.toUpperCase(chars[i+1]);
                        }
                        break;
                    }
                } 
            }
        }
        return String.valueOf(chars);
    }


    private static boolean isSurrogate(char chr){
        // Check if the current character is part of an UTF-16 Surrogate Pair.  
        // Note: not validating the pair, just used to bypass (any found part of) it.
        return (Character.isHighSurrogate(chr) || Character.isLowSurrogate(chr));
    }       

    private static List<Delimiter> getDefaultDelimiters(){
        // If no delimiter specified, "Capitalize after space" rule is set by default. 
        List<Delimiter> delimiters = new ArrayList<Delimiter>();
        delimiters.add(new Delimiter(Behavior.CAPITALIZE_AFTER_MARKER, ' '));
        return delimiters;
    } 

    public static class Delimiter {
        private Behavior behavior;
        private char delimiter;

        public Delimiter(Behavior behavior, char delimiter) {
            super();
            this.behavior = behavior;
            this.delimiter = delimiter;
        }

        public boolean capitalizeBefore(){
            return (behavior.equals(Behavior.CAPITALIZE_BEFORE_MARKER)
                    || behavior.equals(Behavior.CAPITALIZE_BEFORE_AND_AFTER_MARKER));
        }

        public boolean capitalizeAfter(){
            return (behavior.equals(Behavior.CAPITALIZE_AFTER_MARKER)
                    || behavior.equals(Behavior.CAPITALIZE_BEFORE_AND_AFTER_MARKER));
        }

        public char getDelimiter() {
            return delimiter;
        }
    }

    public static enum Behavior {
        CAPITALIZE_AFTER_MARKER(0),
        CAPITALIZE_BEFORE_MARKER(1),
        CAPITALIZE_BEFORE_AND_AFTER_MARKER(2);                      

        private int value;          

        private Behavior(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }           
    } 

15
String toBeCapped = "i want this sentence capitalized";

String[] tokens = toBeCapped.split("\\s");
toBeCapped = "";

for(int i = 0; i < tokens.length; i++){
    char capLetter = Character.toUpperCase(tokens[i].charAt(0));
    toBeCapped +=  " " + capLetter + tokens[i].substring(1);
}
toBeCapped = toBeCapped.trim();

1
Hmmm, je pense que la deuxième ligne de la boucle for devrait se lire: toBeCapped + = "" + capLetter + tokens [i] .substring (1, tokens [i] .length ());
jengelsma

1
Mais cette solution ajoutera un espace au début. Il vous faudra donc peut-être faire la garniture gauche.
Kamalakannan J

13

J'ai fait une solution en Java 8 qui est IMHO plus lisible.

public String firstLetterCapitalWithSingleSpace(final String words) {
    return Stream.of(words.trim().split("\\s"))
    .filter(word -> word.length() > 0)
    .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1))
    .collect(Collectors.joining(" "));
}

L'essentiel de cette solution peut être trouvé ici: https://gist.github.com/Hylke1982/166a792313c5e2df9d31


10

L'utilisation le org.apache.commons.lang.StringUtilsrend très simple.

capitalizeStr = StringUtils.capitalize(str);

2
@Ash StringUtils.capitalise(str)est obsolète. Voir: commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/...
Navigatron

Cela met uniquement en majuscule le premier caractère de la chaîne et non le premier caractère de chaque mot de la chaîne. WordUtils est seulement déconseillés parce qu'il est passé de communes lang à communes texte commons.apache.org/proper/commons-text/javadocs/api-release/org/...
opticyclic

Ce n'est pas une bonne idée d'utiliser une bibliothèque externe pour peu de tâches.
Débordement de pile le

7

Avec ce code simple :

String example="hello";

example=example.substring(0,1).toUpperCase()+example.substring(1, example.length());

System.out.println(example);

Résultat: bonjour


6
Qu'en est-il de BONJOUR, il renvoie BONJOUR, mais attendez Bonjour, vous devez donc utiliser toLowerCase () dans la deuxième sous-chaîne
Trikaldarshi

5

J'utilise la fonction suivante. Je pense que c'est plus rapide dans les performances.

public static String capitalize(String text){
    String c = (text != null)? text.trim() : "";
    String[] words = c.split(" ");
    String result = "";
    for(String w : words){
        result += (w.length() > 1? w.substring(0, 1).toUpperCase(Locale.US) + w.substring(1, w.length()).toLowerCase(Locale.US) : w) + " ";
    }
    return result.trim();
}

3
Utilisez toujours StringBuilder lorsque vous concaténez plutôt que + =
chitgoks

2
Pourquoi pensez-vous que c'est plus rapide?
Peter Mortensen

5

Depuis Java 9+

vous pouvez utiliser String::replaceAllcomme ceci:

public static void upperCaseAllFirstCharacter(String text) {
    String regex = "\\b(.)(.*?)\\b";
    String result = Pattern.compile(regex).matcher(text).replaceAll(
            matche -> matche.group(1).toUpperCase() + matche.group(2)
    );

    System.out.println(result);
}

Exemple :

upperCaseAllFirstCharacter("hello this is Just a test");

Les sorties

Hello This Is Just A Test

4

Utilisez la méthode Split pour diviser votre chaîne en mots, puis utilisez les fonctions de chaîne intégrées pour mettre en majuscule chaque mot, puis ajoutez-les ensemble.

Pseudo-code (ish)

string = "the sentence you want to apply caps to";
words = string.split(" ") 
string = ""
for(String w: words)

//This line is an easy way to capitalize a word
    word = word.toUpperCase().replace(word.substring(1), word.substring(1).toLowerCase())

    string += word

À la fin, la chaîne ressemble à "La phrase à laquelle vous souhaitez appliquer des majuscules"


4

Cela peut être utile si vous devez mettre des titres en majuscule. Il met en majuscule chaque sous-chaîne délimitée par " ", à l'exception des chaînes spécifiées telles que "a"ou "the". Je ne l'ai pas encore couru parce qu'il est tard, ça devrait aller. Utilise Apache Commons StringUtils.join()à un moment donné. Vous pouvez le remplacer par une simple boucle si vous le souhaitez.

private static String capitalize(String string) {
    if (string == null) return null;
    String[] wordArray = string.split(" "); // Split string to analyze word by word.
    int i = 0;
lowercase:
    for (String word : wordArray) {
        if (word != wordArray[0]) { // First word always in capital
            String [] lowercaseWords = {"a", "an", "as", "and", "although", "at", "because", "but", "by", "for", "in", "nor", "of", "on", "or", "so", "the", "to", "up", "yet"};
            for (String word2 : lowercaseWords) {
                if (word.equals(word2)) {
                    wordArray[i] = word;
                    i++;
                    continue lowercase;
                }
            }
        }
        char[] characterArray = word.toCharArray();
        characterArray[0] = Character.toTitleCase(characterArray[0]);
        wordArray[i] = new String(characterArray);
        i++;
    }
    return StringUtils.join(wordArray, " "); // Re-join string
}

Se casse si la chaîne contient des espaces doubles, ce qui est muet pour l'entrée, mais pour info.
JustTrying

4
public static String toTitleCase(String word){
    return Character.toUpperCase(word.charAt(0)) + word.substring(1);
}

public static void main(String[] args){
    String phrase = "this is to be title cased";
    String[] splitPhrase = phrase.split(" ");
    String result = "";

    for(String word: splitPhrase){
        result += toTitleCase(word) + " ";
    }
    System.out.println(result.trim());
}

Bienvenue dans Stack Overflow! Généralement, les réponses sont beaucoup plus utiles si elles incluent une explication de ce que le code est censé faire et pourquoi cela résout le problème sans en introduire d'autres.
Neuron

La solution la plus simple de loin et évite d'utiliser des
bibliothèques

3
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));   

System.out.println("Enter the sentence : ");

try
{
    String str = br.readLine();
    char[] str1 = new char[str.length()];

    for(int i=0; i<str.length(); i++)
    {
        str1[i] = Character.toLowerCase(str.charAt(i));
    }

    str1[0] = Character.toUpperCase(str1[0]);
    for(int i=0;i<str.length();i++)
    {
        if(str1[i] == ' ')
        {                   
            str1[i+1] =  Character.toUpperCase(str1[i+1]);
        }
        System.out.print(str1[i]);
    }
}
catch(Exception e)
{
    System.err.println("Error: " + e.getMessage());
}

C'est la réponse la plus simple, la plus simple et la plus simple pour un novice comme moi!
abhishah901

3

J'ai décidé d'ajouter une autre solution pour mettre les mots en majuscule dans une chaîne:

  • les mots sont définis ici comme des lettres ou des chiffres adjacents;
  • des paires de substitution sont également fournies;
  • le code a été optimisé pour les performances; et
  • il est toujours compact.

Une fonction:

public static String capitalize(String string) {
  final int sl = string.length();
  final StringBuilder sb = new StringBuilder(sl);
  boolean lod = false;
  for(int s = 0; s < sl; s++) {
    final int cp = string.codePointAt(s);
    sb.appendCodePoint(lod ? Character.toLowerCase(cp) : Character.toUpperCase(cp));
    lod = Character.isLetterOrDigit(cp);
    if(!Character.isBmpCodePoint(cp)) s++;
  }
  return sb.toString();
}

Exemple d'appel:

System.out.println(capitalize("An à la carte StRiNg. Surrogate pairs: 𐐪𐐪."));

Résultat:

An À La Carte String. Surrogate Pairs: 𐐂𐐪.

3

Utilisation:

    String text = "jon skeet, miles o'brien, old mcdonald";

    Pattern pattern = Pattern.compile("\\b([a-z])([\\w]*)");
    Matcher matcher = pattern.matcher(text);
    StringBuffer buffer = new StringBuffer();
    while (matcher.find()) {
        matcher.appendReplacement(buffer, matcher.group(1).toUpperCase() + matcher.group(2));
    }
    String capitalized = matcher.appendTail(buffer).toString();
    System.out.println(capitalized);

Fonctionne parfaitement avec toLowerCase -> "Matcher matcher = pattern.matcher (text.toLowerCase ());" (Pour le texte d'entrée comme "JOHN DOE")
smillien62

3

Il existe plusieurs façons de convertir la première lettre du premier mot en majuscule. J'ai une idée. C'est très simple:

public String capitalize(String str){

     /* The first thing we do is remove whitespace from string */
     String c = str.replaceAll("\\s+", " ");
     String s = c.trim();
     String l = "";

     for(int i = 0; i < s.length(); i++){
          if(i == 0){                              /* Uppercase the first letter in strings */
              l += s.toUpperCase().charAt(i);
              i++;                                 /* To i = i + 1 because we don't need to add               
                                                    value i = 0 into string l */
          }

          l += s.charAt(i);

          if(s.charAt(i) == 32){                   /* If we meet whitespace (32 in ASCII Code is whitespace) */
              l += s.toUpperCase().charAt(i+1);    /* Uppercase the letter after whitespace */
              i++;                                 /* Yo i = i + 1 because we don't need to add
                                                   value whitespace into string l */
          }        
     }
     return l;
}

Merci d'avoir essayé d'ajouter une réponse. C'est une idée raisonnable, mais notez qu'il existe déjà des fonctions de base et un code qui le fait de la même manière que ce que vous avez fourni, et les réponses acceptées les décrivent déjà toutes très clairement.
David Manheim

2
  package com.test;

 /**
   * @author Prasanth Pillai
   * @date 01-Feb-2012
   * @description : Below is the test class details
   * 
   * inputs a String from a user. Expect the String to contain spaces and    alphanumeric     characters only.
   * capitalizes all first letters of the words in the given String.
   * preserves all other characters (including spaces) in the String.
   * displays the result to the user.
   * 
   * Approach : I have followed a simple approach. However there are many string    utilities available 
   * for the same purpose. Example : WordUtils.capitalize(str) (from apache commons-lang)
   *
   */
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;

  public class Test {

public static void main(String[] args) throws IOException{
    System.out.println("Input String :\n");
    InputStreamReader converter = new InputStreamReader(System.in);
    BufferedReader in = new BufferedReader(converter);
    String inputString = in.readLine();
    int length = inputString.length();
    StringBuffer newStr = new StringBuffer(0);
    int i = 0;
    int k = 0;
    /* This is a simple approach
     * step 1: scan through the input string
     * step 2: capitalize the first letter of each word in string
     * The integer k, is used as a value to determine whether the 
     * letter is the first letter in each word in the string.
     */

    while( i < length){
        if (Character.isLetter(inputString.charAt(i))){
            if ( k == 0){
            newStr = newStr.append(Character.toUpperCase(inputString.charAt(i)));
            k = 2;
            }//this else loop is to avoid repeatation of the first letter in output string 
            else {
            newStr = newStr.append(inputString.charAt(i));
            }
        } // for the letters which are not first letter, simply append to the output string. 
        else {
            newStr = newStr.append(inputString.charAt(i));
            k=0;
        }
        i+=1;           
    }
    System.out.println("new String ->"+newStr);
    }
}

2

Voici une fonction simple

public static String capEachWord(String source){
    String result = "";
    String[] splitString = source.split(" ");
    for(String target : splitString){
        result += Character.toUpperCase(target.charAt(0))
                + target.substring(1) + " ";
    }
    return result.trim();
}

1
N'utilisez pas la conciliation de chaînes pour créer de longues chaînes, c'est douloureusement lent: stackoverflow.com/questions/15177987/…
Lukas Knuth

2

C'est juste une autre façon de procéder:

private String capitalize(String line)
{
    StringTokenizer token =new StringTokenizer(line);
    String CapLine="";
    while(token.hasMoreTokens())
    {
        String tok = token.nextToken().toString();
        CapLine += Character.toUpperCase(tok.charAt(0))+ tok.substring(1)+" ";        
    }
    return CapLine.substring(0,CapLine.length()-1);
}

2

Méthode réutilisable pour intiCap:

    public class YarlagaddaSireeshTest{

    public static void main(String[] args) {
        String FinalStringIs = "";
        String testNames = "sireesh yarlagadda test";
        String[] name = testNames.split("\\s");

        for(String nameIs :name){
            FinalStringIs += getIntiCapString(nameIs) + ",";
        }
        System.out.println("Final Result "+ FinalStringIs);
    }

    public static String getIntiCapString(String param) {
        if(param != null && param.length()>0){          
            char[] charArray = param.toCharArray(); 
            charArray[0] = Character.toUpperCase(charArray[0]); 
            return new String(charArray); 
        }
        else {
            return "";
        }
    }
}

2

Voici ma solution.

J'ai rencontré ce problème ce soir et j'ai décidé de le rechercher. J'ai trouvé une réponse de Neelam Singh qui était presque là, alors j'ai décidé de résoudre le problème (cassé sur les chaînes vides) et provoqué un plantage du système.

La méthode que vous recherchez est nommée capString(String s) ci-dessous. Il transforme "Il est seulement 5 heures du matin ici" en "Il est seulement 5 heures du matin ici".

Le code est assez bien commenté, alors profitez-en.

package com.lincolnwdaniel.interactivestory.model;

    public class StringS {

    /**
     * @param s is a string of any length, ideally only one word
     * @return a capitalized string.
     * only the first letter of the string is made to uppercase
     */
    public static String capSingleWord(String s) {
        if(s.isEmpty() || s.length()<2) {
            return Character.toUpperCase(s.charAt(0))+"";
        } 
        else {
            return Character.toUpperCase(s.charAt(0)) + s.substring(1);
        }
    }

    /**
     *
     * @param s is a string of any length
     * @return a title cased string.
     * All first letter of each word is made to uppercase
     */
    public static String capString(String s) {
        // Check if the string is empty, if it is, return it immediately
        if(s.isEmpty()){
            return s;
        }

        // Split string on space and create array of words
        String[] arr = s.split(" ");
        // Create a string buffer to hold the new capitalized string
        StringBuffer sb = new StringBuffer();

        // Check if the array is empty (would be caused by the passage of s as an empty string [i.g "" or " "],
        // If it is, return the original string immediately
        if( arr.length < 1 ){
            return s;
        }

        for (int i = 0; i < arr.length; i++) {
            sb.append(Character.toUpperCase(arr[i].charAt(0)))
                    .append(arr[i].substring(1)).append(" ");
        }
        return sb.toString().trim();
    }
}

2

1. Flux Java 8

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

    return Arrays.stream(str.split("\\s+"))
            .map(t -> t.substring(0, 1).toUpperCase() + t.substring(1))
            .collect(Collectors.joining(" "));
}

Exemples:

System.out.println(capitalizeAll("jon skeet")); // Jon Skeet
System.out.println(capitalizeAll("miles o'Brien")); // Miles O'Brien
System.out.println(capitalizeAll("old mcdonald")); // Old Mcdonald
System.out.println(capitalizeAll(null)); // null

Pour foo bARto Foo Bar, remplacez la map()méthode par ce qui suit:

.map(t -> t.substring(0, 1).toUpperCase() + t.substring(1).toLowerCase())

2. String.replaceAll()(Java 9+)

ublic static String capitalizeAll(String str) {
    if (str == null || str.isEmpty()) {
        return str;
    }

    return Pattern.compile("\\b(.)(.*?)\\b")
            .matcher(str)
            .replaceAll(match -> match.group(1).toUpperCase() + match.group(2));
}

Exemples:

System.out.println(capitalizeAll("12 ways to learn java")); // 12 Ways To Learn Java
System.out.println(capitalizeAll("i am atta")); // I Am Atta
System.out.println(capitalizeAll(null)); // null

3. Texte Apache Commons

System.out.println(WordUtils.capitalize("love is everywhere")); // Love Is Everywhere
System.out.println(WordUtils.capitalize("sky, sky, blue sky!")); // Sky, Sky, Blue Sky!
System.out.println(WordUtils.capitalize(null)); // null

Pour titlecase:

System.out.println(WordUtils.capitalizeFully("fOO bAR")); // Foo Bar
System.out.println(WordUtils.capitalizeFully("sKy is BLUE!")); // Sky Is Blue!

Pour plus de détails, consultez ce didacticiel .



1
String s="hi dude i                                 want apple";
    s = s.replaceAll("\\s+"," ");
    String[] split = s.split(" ");
    s="";
    for (int i = 0; i < split.length; i++) {
        split[i]=Character.toUpperCase(split[i].charAt(0))+split[i].substring(1);
        s+=split[i]+" ";
        System.out.println(split[i]);
    }
    System.out.println(s);

1
package corejava.string.intern;

import java.io.DataInputStream;

import java.util.ArrayList;

/*
 * wap to accept only 3 sentences and convert first character of each word into upper case
 */

public class Accept3Lines_FirstCharUppercase {

    static String line;
    static String words[];
    static ArrayList<String> list=new ArrayList<String>();

    /**
     * @param args
     */
    public static void main(String[] args) throws java.lang.Exception{

        DataInputStream read=new DataInputStream(System.in);
        System.out.println("Enter only three sentences");
        int i=0;
        while((line=read.readLine())!=null){
            method(line);       //main logic of the code
            if((i++)==2){
                break;
            }
        }
        display();
        System.out.println("\n End of the program");

    }

    /*
     * this will display all the elements in an array
     */
    public static void display(){
        for(String display:list){
            System.out.println(display);
        }
    }

    /*
     * this divide the line of string into words 
     * and first char of the each word is converted to upper case
     * and to an array list
     */
    public static void method(String lineParam){
        words=line.split("\\s");
        for(String s:words){
            String result=s.substring(0,1).toUpperCase()+s.substring(1);
            list.add(result);
        }
    }

}

1

Si vous préférez la goyave ...

String myString = ...;

String capWords = Joiner.on(' ').join(Iterables.transform(Splitter.on(' ').omitEmptyStrings().split(myString), new Function<String, String>() {
    public String apply(String input) {
        return Character.toUpperCase(input.charAt(0)) + input.substring(1);
    }
}));

1
String toUpperCaseFirstLetterOnly(String str) {
    String[] words = str.split(" ");
    StringBuilder ret = new StringBuilder();
    for(int i = 0; i < words.length; i++) {
        ret.append(Character.toUpperCase(words[i].charAt(0)));
        ret.append(words[i].substring(1));
        if(i < words.length - 1) {
            ret.append(' ');
        }
    }
    return ret.toString();
}

1

La manière courte et précise est la suivante:

String name = "test";

name = (name.length() != 0) ?name.toString().toLowerCase().substring(0,1).toUpperCase().concat(name.substring(1)): name;
--------------------
Output
--------------------
Test
T 
empty
--------------------

Cela fonctionne sans erreur si vous essayez de changer la valeur du nom en trois valeurs. Sans erreur.


et si c'est plus d'un mot
luckyguy73
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.