So schreiben Sie das erste Zeichen jedes Wortes in einer Zeichenfolge groß

421

Gibt es eine in Java integrierte Funktion, die das erste Zeichen jedes Wortes in einem String großschreibt und die anderen nicht beeinflusst?

Beispiele:

  • jon skeet -> Jon Skeet
  • miles o'Brien-> Miles O'Brien(B bleibt Kapital, dies schließt Titelfall aus)
  • old mcdonald-> Old Mcdonald*

* ( Old McDonaldwäre auch zu finden, aber ich erwarte nicht, dass es so klug ist.)

Ein kurzer Blick auf die Java-String-Dokumentation zeigt nur toUpperCase()und toLowerCase(), die natürlich nicht das gewünschte Verhalten bieten. Natürlich werden die Google-Ergebnisse von diesen beiden Funktionen dominiert. Es scheint wie ein Rad, das bereits erfunden worden sein muss, also kann es nicht schaden zu fragen, damit ich es in Zukunft verwenden kann.

WillfulWizard
quelle
18
Was ist mit old mcdonald? Sollte das werden Old McDonald?
Bart Kiers
2
Ich erwarte nicht, dass die Funktion so intelligent ist. (Wenn Sie einen haben, würde ich mich freuen, ihn zu sehen.) Steigern Sie einfach den ersten Buchstaben nach dem Leerzeichen, aber ignorieren Sie den Rest.
WillfulWizard
1
Sie würden ohnehin keinen Algorithmus finden können, der die Großschreibung von Namen nachträglich richtig handhabt ... solange es Namenspaare gibt, von denen einer für eine bestimmte Person wie MacDonald und Macdonald korrekt sein könnte, würde die Funktion dies tun Ich habe keine Möglichkeit zu wissen, was richtig war. Es ist besser, das zu tun, was Sie getan haben, obwohl Sie immer noch einige falsche Namen haben (wie von Neumann).
Dave DuPlantis
Versuchen Sie Burger King ...
Magno C

Antworten:

732

WordUtils.capitalize(str)(aus Apache Commons-Text )

(Hinweis: Wenn Sie benötigen "fOO BAr"werden "Foo Bar", dann verwenden Sie capitalizeFully(..)stattdessen)

Bozho
quelle
5
Ich denke du meinst WordUtils.capitalize (str). Weitere Informationen finden Sie unter API.
Hans Doggen
84
Ich behalte meine Philosophie bei, immer Antworten abzustimmen, die sich auf die allgemeinen Bibliotheken beziehen.
Ravi Wallau
11
Verwenden Sie großschreibenFully (str), um den nicht ersten Buchstaben in Kleinbuchstaben zu ändern.
Umesh Rajbhandari
5
Ist diese Lösung wirklich richtig ? es ist nicht meiner Meinung nach! Wenn Sie "LAMborghini" groß schreiben möchten, möchten Sie am Ende "Lamborghini". So WordUtils.capitalizeFully(str)ist die Lösung.
BasZero
3
@BasZero ist die richtige Antwort auf die gestellte Frage. Ich werde die Vollversion als Kommentar hinzufügen.
Bozho
229

Wenn Sie sich nur Sorgen machen, dass der erste Buchstabe des ersten Wortes groß geschrieben wird:

private String capitalize(final String line) {
   return Character.toUpperCase(line.charAt(0)) + line.substring(1);
}
Nick Bolton
quelle
3
Dies ändert nur den ersten Buchstaben des ersten Wortes
Chrizzz
28
Dies war in der Tat meine Absicht.
Nick Bolton
13
@nbolton - Aber es ignoriert explizit die Absicht der Frage und schlägt in den in diesem Beispiel angegebenen Fällen fehl - und es fügt den zuvor gegebenen Antworten wenig oder gar nichts hinzu!
David Manheim
17
Dieser Code ist nicht absturzsicher! Stellen Sie sich vor line, Sie sind null oder haben eine Länge von <2.
stk
1
Geben Sie dennoch Character.toUpperCase (word.charAt (0)) + word.substring (1) .toLowerCase () zurück
Exceptyon
72

Die folgende Methode konvertiert alle Buchstaben in Groß- / Kleinbuchstaben, abhängig von ihrer Position in der Nähe eines Leerzeichens oder anderen Sonderzeichen.

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);
}
True Soft
quelle
Ich würde die Schleifenbedingungen verbessern und vereinfachen : if(Character.isLetter(chars[i])) { if(!found) { chars[i] = Character.toUpperCase(chars[i]); } found = true; } else { found = false; }.
Bancer
@bancer, mit Ihrem Beispiel können Sie nicht steuern, auf welche Zeichen kein Großbuchstabe folgt.
True Soft
@ TrueSoft, ich verstehe dich nicht. Warum müssen Sie steuern, welche Zeichen nach dem Großbuchstaben folgen? Nach meinem Verständnis ist es wichtig, dass das vorhergehende Zeichen kein Buchstabe ist, und mein Beispiel stellt dies sicher. Ersetzen Sie einfach Ihren if-else-if-Block durch meinen if-else-Block und führen Sie einen Test durch.
Bancer
@TrueSoft, für Klarheit würde ich umbenennen foundzu previousCharIsLetter.
Bancer
9
Ich mag es, Antworten zu haben, die die Commons-Bibliothek nicht verwenden, weil Sie sie von Zeit zu Zeit nicht verwenden können.
Heckman
38

Versuchen Sie es auf sehr einfache Weise

Beispiel angegebenString = "RAM ist ein guter Junge"

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

Ausgabe wird sein: Ram ist guter Junge

Neelam Singh
quelle
1
Dieser Code hat unseren Server zum Absturz gebracht: java.lang.StringIndexOutOfBoundsException: String-Index außerhalb des Bereichs: 0
Chrizzz
32
@Chrizzz also keinen Code festschreiben, den Sie nicht getestet haben ... Wenn Sie eine leere Zeichenfolge angeben, stürzt diese ab. Deine Schuld, nicht die von Neelam.
Reinherd
1
Wenn am Ende ein Leerzeichen steht, stürzt es ab, dann habe ich zuerst trim () hinzugefügt und die Zeichenfolge mit Leerzeichen geteilt. Es hat perfekt funktioniert
Hanuman
Falls jemand nach seiner Kotlin-Version sucht, hier ist sie: stackoverflow.com/a/55390188/1708390
Bugs Happen
16

Ich habe eine kleine Klasse geschrieben, um alle Wörter in einem String groß zu schreiben.

Optional multiple delimiters, jeder mit seinem Verhalten (vor, nach oder beiden groß schreiben, um Fälle wie zu behandeln O'Brian);

Optional Locale;

Brich nicht mit Surrogate Pairs.

LIVE DEMO

Ausgabe:

====================================
 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 À

Hinweis: Der erste Buchstabe wird immer groß geschrieben (bearbeiten Sie die Quelle, wenn Sie das nicht möchten).

Bitte teilen Sie Ihre Kommentare und helfen Sie mir, Fehler zu finden oder den Code zu verbessern ...

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;
        }           
    } 
Andrea Ligios
quelle
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();
Reid Mac
quelle
1
Hmmm, ich denke die zweite Zeile in der for-Schleife sollte lauten: toBeCapped + = "" + capLetter + tokens [i] .substring (1, tokens [i] .length ());
Jengelsma
1
Diese Lösung fügt jedoch zu Beginn ein Leerzeichen hinzu. Möglicherweise müssen Sie also die linke Trimmung vornehmen.
Kamalakannan J
13

Ich habe eine Lösung in Java 8 gemacht, die meiner Meinung nach besser lesbar ist.

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

Das Wesentliche für diese Lösung finden Sie hier: https://gist.github.com/Hylke1982/166a792313c5e2df9d31

Hylke1982
quelle
10

Die Verwendung org.apache.commons.lang.StringUtilsmacht es sehr einfach.

capitalizeStr = StringUtils.capitalize(str);
Amir Bareket
quelle
2
@Ash StringUtils.capitalise(str)ist veraltet. Siehe: commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/…
Navigatron
Dadurch wird nur das erste Zeichen der Zeichenfolge großgeschrieben, nicht das erste Zeichen jedes Wortes in der Zeichenfolge. WordUtils ist nur veraltet, weil es von commons lang zu commons text commons.apache.org/proper/commons-text/javadocs/api-release/org/…
opticyclic
Keine gute Idee, eine externe Bibliothek für kleine Aufgaben zu verwenden.
Stapelüberlauf
7

Mit diesem einfachen Code :

String example="hello";

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

System.out.println(example);

Ergebnis: Hallo

Adrian
quelle
6
Was ist mit HALLO? Es gibt HALLO zurück, aber erwartet Hallo, also sollst du toLowerCase () im zweiten SubString
Trikaldarshi
5

Ich benutze die folgende Funktion. Ich denke, es ist schneller in der Leistung.

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();
}
Tassadar
quelle
3
Verwenden Sie immer StringBuilder, wenn Sie eher verketten als + =
chitgoks
2
Warum denkst du, ist es schneller?
Peter Mortensen
5

Ab Java 9+

Sie können String::replaceAllwie folgt verwenden:

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

Beispiel:

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

Ausgänge

Hello This Is Just A Test
YCF_L
quelle
4

Verwenden Sie die Split-Methode, um Ihre Zeichenfolge in Wörter aufzuteilen. Verwenden Sie dann die integrierten Zeichenfolgenfunktionen, um jedes Wort in Großbuchstaben zu schreiben, und fügen Sie sie dann zusammen.

Pseudocode (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

Am Ende sieht die Zeichenfolge ungefähr so ​​aus wie "Der Satz, auf den Sie Großbuchstaben anwenden möchten".

Paul
quelle
4

Dies kann nützlich sein, wenn Sie Titel groß schreiben müssen. Es wird jede durch begrenzte " "Teilzeichenfolge groß geschrieben , mit Ausnahme bestimmter Zeichenfolgen wie "a"oder "the". Ich habe es noch nicht ausgeführt, weil es spät ist, sollte aber in Ordnung sein. Verwendet Apache Commons StringUtils.join()an einem Punkt. Sie können es durch eine einfache Schleife ersetzen, wenn Sie möchten.

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
}
Dominykas Mostauskis
quelle
Bricht, wenn der String doppelte Leerzeichen enthält, was für die Eingabe dumm ist, aber zu Ihrer Information.
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());
}
Taladork
quelle
Willkommen bei Stack Overflow! Im Allgemeinen sind Antworten viel hilfreicher, wenn sie eine Erklärung enthalten, was der Code tun soll und warum dies das Problem löst, ohne andere einzuführen.
Neuron
Mit Abstand
einfachste
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());
}
Suganya
quelle
Dies ist die einfachste, einfachste und beste Antwort für einen Neuling wie mich!
Abhishah901
3

Ich habe beschlossen, eine weitere Lösung zum Großschreiben von Wörtern in einer Zeichenfolge hinzuzufügen:

  • Wörter werden hier als benachbarte Buchstaben- oder Ziffernzeichen definiert;
  • Ersatzpaare werden ebenfalls bereitgestellt;
  • Der Code wurde für die Leistung optimiert. und
  • es ist immer noch kompakt.

Funktion:

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

Beispielaufruf:

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

Ergebnis:

An À La Carte String. Surrogate Pairs: 𐐂𐐪.
Christian Grün
quelle
3

Verwenden:

    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);
curd0
quelle
Funktioniert perfekt mit toLowerCase -> "Matcher matcher = pattern.matcher (text.toLowerCase ());" (Für Eintragstext wie "JOHN DOE")
smillien62
3

Es gibt viele Möglichkeiten, den ersten Buchstaben des ersten großgeschriebenen Wortes umzuwandeln. Ich habe eine Idee. Es ist sehr einfach:

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;
}
Phuoc Le
quelle
Vielen Dank, dass Sie versucht haben, eine Antwort hinzuzufügen. Dies ist eine vernünftige Idee, aber beachten Sie, dass es bereits Grundfunktionen gibt, die dies tun, und Code, der dies ähnlich wie von Ihnen angegeben tut, und die akzeptierten Antworten umreißen bereits alle sehr klar.
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);
    }
}
Prasanth
quelle
2

Hier ist eine einfache Funktion

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();
}
Himanshu Agrawal
quelle
1
Verwenden Sie keine String-Concation zum Erstellen langer Strings, es ist schmerzhaft langsam: stackoverflow.com/questions/15177987/…
Lukas Knuth
2

Dies ist nur eine andere Möglichkeit:

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);
}
foobar
quelle
2

Wiederverwendbare Methode für 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 "";
        }
    }
}
Sireesh Yarlagadda
quelle
2

Hier ist meine Lösung.

Ich bin heute Abend auf dieses Problem gestoßen und habe beschlossen, es zu durchsuchen. Ich fand eine Antwort von Neelam Singh, die fast da war, also entschied ich mich, das Problem zu beheben (brach auf leeren Zeichenfolgen) und verursachte einen Systemabsturz.

Die Methode, nach der Sie suchen, ist capString(String s)unten aufgeführt. Es verwandelt "Es ist nur 5 Uhr morgens hier" in "Es ist nur 5 Uhr morgens hier".

Der Code ist ziemlich gut kommentiert, also viel Spaß.

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

1. Java 8 Streams

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

Beispiele:

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

Für foo bARzu Foo Bar, ersetzen Sie die map()Methode mit dem folgenden:

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

Beispiele:

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. Apache Commons Text

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

Für den Titelfall:

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

Weitere Informationen finden Sie in diesem Tutorial .

Attacomsian
quelle
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);
Wohlfühlen und Programmieren
quelle
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);
        }
    }

}
Elias Sheikh
quelle
1

Wenn Sie Guave bevorzugen ...

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);
    }
}));
aaronvargas
quelle
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();
}
Krunal
quelle
1

Der kurze und präzise Weg ist wie folgt:

String name = "test";

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

Es funktioniert ohne Fehler, wenn Sie versuchen, den Namenswert in die drei Werte zu ändern. Fehlerfrei.

Daniel Adenew
quelle
Was ist, wenn es mehr als ein Wort ist
Luckyguy73