webentwicklung-frage-antwort-db.com.de

Wie wird das erste Zeichen eines jeden Wortes in einer Zeichenfolge groß geschrieben?

Gibt es eine in Java integrierte Funktion, die das erste Zeichen jedes Words 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 McDonald wäre auch zu finden, aber ich erwarte nicht, dass es so intelligent ist.)

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

371
WillfulWizard

WordUtils.capitalize(str) (aus Apache commons-text )

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

673
Bozho

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);
}
223
Nick Bolton

Die folgende Methode konvertiert alle Buchstaben in Groß-/Kleinschreibung, abhängig von ihrer Position in der Nähe eines Leerzeichens oder anderer 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);
}
61
True Soft

Versuchen Sie es auf ganz einfache Weise

example givenString = "RAM ist 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();
}  

Es wird ausgegeben: Ram Is Good Boy

32
Neelam Singh

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

Optional multiple delimiters, jeder mit seinem Verhalten (Groß-/Kleinschreibung vor, nach oder beides, um Fälle wie O'Brian zu behandeln);

Optional Locale

Bricht nicht mit Surrogate Pairs ab.

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 dies 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;
        }           
    } 
16
Andrea Ligios
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();
15
Reid Mac

Die Verwendung von org.Apache.commons.lang.StringUtils macht es sehr einfach.

capitalizeStr = StringUtils.capitalize(str);
10
Amir Bareket

Ich habe eine Lösung in Java 8 gemacht, die IMHO 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(" "));
}

Die Gist für diese Lösung finden Sie hier: https://Gist.github.com/Hylke1982/166a792313c5e2df9d31

8
Hylke1982

Mit diesem einfachen Code :

String example="hello";

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

System.out.println(example);

Ergebnis: Hallo

6
Adrian

Ich verwende 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();
}
5
Tassadar
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());
}
4
Taladork

Dies kann nützlich sein, wenn Sie Titel groß schreiben müssen. Es wird jede durch " " begrenzte Teilzeichenfolge großgeschrieben, mit Ausnahme der angegebenen Zeichenfolgen wie "a" oder "the". Ich habe es noch nicht ausgeführt, weil es zu spät ist, sollte aber auch in Ordnung sein. Verwendet an einem Punkt Apache Commons StringUtils.join() . 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
}

Verwenden Sie die Split-Methode, um Ihre Zeichenfolge in Wörter aufzuteilen. Verwenden Sie dann die integrierten Zeichenfolgenfunktionen, um jedes Wort groß zu schreiben, und fügen Sie es anschließend 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 String so aus wie .__ "Der Satz, auf den Sie Caps anwenden möchten"

4
Paul

Es gibt viele Möglichkeiten, den ersten Buchstaben des ersten Wortes, das großgeschrieben wird, 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;
}
3
Phuoc Le

Von Java 9+

sie können String::replceAll wie 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");

Ausgaben

Hello This Is Just A Test
3
YCF_L
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());
}
3
Suganya

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

Ich entschied mich für eine weitere Lösung, um Wörter in einer Zeichenfolge groß zu schreiben:

  • wörter werden hier als benachbarte Buchstaben oder Ziffern definiert;
  • ersatzpaare sind ebenfalls vorhanden;
  • der Code wurde auf 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();
}

Beispielanruf:

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

Ergebnis:

An À La Carte String. Surrogate Pairs: ????????.
3
Christian Grün

Benutzen:

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

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

Hier ist meine Lösung.

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

Die von Ihnen gesuchte Methode wird im Folgenden als capString(String s) bezeichnet. Es macht aus "Es ist erst 5 Uhr hier" in "Es ist nur 5 Uhr 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();
    }
}
2
lwdthe1

Dies ist nur eine andere Möglichkeit, dies zu tun:

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
foobar

Dieser arbeitet für den Nachnamen-Fall ...

Mit verschiedenen Arten von Trennzeichen, und es behält das gleiche Trennzeichen bei:

  • jean-Frederic -> Jean-Frederic

  • jean Frederic -> Jean Frederic

Der Code funktioniert mit der GWT-Clientseite.

public static String capitalize (String givenString) {
    String Separateur = " ,.-;";
    StringBuffer sb = new StringBuffer(); 
    boolean ToCap = true;
    for (int i = 0; i < givenString.length(); i++) {
        if (ToCap)              
            sb.append(Character.toUpperCase(givenString.charAt(i)));
        else
            sb.append(Character.toLowerCase(givenString.charAt(i)));

        if (Separateur.indexOf(givenString.charAt(i)) >=0) 
            ToCap = true;
        else
            ToCap = false;
    }          
    return sb.toString().trim();
}  
1
jf Wastiaux
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
Elias Sheikh

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

Für diejenigen, die Velocity in Ihrer MVC verwenden, können Sie die capitalizeFirstLetter()-Methode aus der StringUtils-Klasse verwenden.

1
Shogo Yahagi
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
Krunal

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 fehlerfrei, wenn Sie versuchen, den Namenswert in drei Werte zu ändern. Fehlerfrei.

1
danielad

Versuche dies:

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

Ich benutze wordUppercase(String s) aus der Raindrop-Library . Da dies meine Bibliothek ist, hier die einzige Methode:

 /**
  * Set set first letter from every Word uppercase.
  *
  * @param s - The String wich you want to convert.
  * @return The string where is the first letter of every Word uppercase.
  */
 public static String wordUppercase(String s){
   String[] words = s.split(" ");
   for (int i = 0; i < words.length; i++) words[i] = words[i].substring(0, 1).toUpperCase() + words[i].substring(1).toLowerCase();
   return String.join(" ", words);
 }

Ich hoffe es hilft :)

0
Simon

Hier ist RxJava Lösung für das Problem

    String title = "this is a title";
    StringBuilder stringBuilder = new StringBuilder();
    Observable.fromArray(title.trim().split("\\s"))
        .map(Word -> Word.substring(0, 1).toUpperCase() + Word.substring(1).toLowerCase())
        .toList()
        .map(wordList -> {
            for (String Word : wordList) {
                stringBuilder.append(Word).append(" ");
            }
            return stringBuilder.toString();
        })
        .subscribe(result -> System.out.println(result));

Ich mag die For-Loop-Karte jedoch noch nicht.

0
Abhishek Bansal
    s.toLowerCase().trim();
    result += Character.toUpperCase(s.charAt(0));
    result += s.substring(1, s.indexOf(" ") + 1);
    s = s.substring(s.indexOf(" ") + 1);

    do {
        if (s.contains(" ")) {
            result += " ";
            result += Character.toUpperCase(s.charAt(0));
            result += s.substring(1, s.indexOf(" "));
            s = s.substring(s.indexOf(" ") + 1);
        } else {
            result += " ";
            result += Character.toUpperCase(s.charAt(0));
            result += s.substring(1);
            break;
        }
    } while (true);
    System.out.println(result);
0
Thaycacac

Ich möchte nur eine alternative Lösung für das Problem hinzufügen, indem ich nur Java-Code verwende. Keine extra Bibliothek

public String Capitalize(String str) {

            String tt = "";
            String tempString = "";
            String tempName = str.trim().toLowerCase();
            String[] tempNameArr = tempName.split(" ");
            System.out.println("The size is " + tempNameArr.length);
            if (tempNameArr.length > 1) {
                for (String t : tempNameArr) {
                    tt += Capitalize(t);
                    tt += " ";
                }
                tempString  = tt;
            } else {
                tempString = tempName.replaceFirst(String.valueOf(tempName.charAt(0)), String.valueOf(tempName.charAt(0)).toUpperCase());
            }
            return tempString.trim();
        }
0
public void capitaliseFirstLetterOfEachWord()
{
    String value="this will capitalise first character of each Word of this string";
    String[] wordSplit=value.split(" ");
    StringBuilder sb=new StringBuilder();

    for (int i=0;i<wordSplit.length;i++){

        sb.append(wordSplit[i].substring(0,1).toUpperCase().
                concat(wordSplit[i].substring(1)).concat(" "));
    }
    System.out.println(sb);
}
0
Shristy
String text="hello";
StringBuffer sb=new StringBuffer();
char[] ch=text.toCharArray();
for(int i=0;i<ch.length;i++){
    if(i==0){
        sb.append(Character.toUpperCase(ch[i]));
    }
    else{
    sb.append(ch[i]);
    }
}


text=sb.toString();
System.out.println(text);
}
0
Arun Raaj

Hier ist ein kleines Programm, mit dem ich jeden ersten Buchstaben Word in jedem Unterordner eines übergeordneten Verzeichnisses groß geschrieben habe.

private void capitalize(String string)
{
    List<String> delimiters = new ArrayList<>();
    delimiters.add(" ");
    delimiters.add("_");

    File folder = new File(string);
    String name = folder.getName();
    String[] characters = name.split("");

    String newName = "";
    boolean capitalizeNext = false;

    for (int i = 0; i < characters.length; i++)
    {
        String character = characters[i];

        if (capitalizeNext || i == 0)
        {
            newName += character.toUpperCase();
            capitalizeNext = false;
        }
        else
        {
            if (delimiters.contains(character)) capitalizeNext = true;
            newName += character;
        }
    }

    folder.renameTo(new File(folder.getParent() + File.separator + newName));
}
0
Dylan Hatch

Da niemand regexp verwendet hat, machen wir es mit regexp. Diese Lösung ist zum Spaß. :) (Update: eigentlich habe ich gerade entdeckt, dass es eine Antwort mit Regexx gibt, trotzdem möchte ich diese Antwort an Ort und Stelle belassen, da sie besser aussehend :)):

public class Capitol 
{
    public static String now(String str)
    {
        StringBuffer b = new StringBuffer();
        Pattern p = Pattern.compile("\\b(\\w){1}");
        Matcher m = p.matcher(str);
        while (m.find())
        {
            String s = m.group(1);
            m.appendReplacement(b, s.toUpperCase());
        }
        m.appendTail(b);
        return b.toString();
    }
}

Verwendungszweck 

Capitol.now("ab cd"));
Capitol.now("winnie the Pooh"));
Capitol.now("please talk loudly!"));
Capitol.now("miles o'Brien"));
0
display_name

Ich hatte die Anforderung, eine generische toString (Object obj) -Helperklassenfunktion zu erstellen, bei der ich die Feldnamen in Methodennamen - getXXX () des übergebenen Objekts umwandeln musste. 

Hier ist der Code 

/**
 * @author DPARASOU
 * Utility method to replace the first char of a string with uppercase but leave other chars as it is.
 * ToString() 
 * @param inStr - String
 * @return String
 */
public static String firstCaps(String inStr)
{
    if (inStr != null && inStr.length() > 0)
    {
        char[] outStr = inStr.toCharArray();
        outStr[0] = Character.toUpperCase(outStr[0]);
        return String.valueOf(outStr);
    }
    else
        return inStr;
}

Und mein Dienstprogramm toString () ist so

public static String getToString(Object obj)
{
    StringBuilder toString = new StringBuilder();
    toString.append(obj.getClass().getSimpleName());
    toString.append("[");
    for(Field f : obj.getClass().getDeclaredFields())
    {
        toString.append(f.getName());
        toString.append("=");
        try{
            //toString.append(f.get(obj)); //access privilege issue
            toString.append(invokeGetter(obj, firstCaps(f.getName()), "get"));
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        toString.append(", ");        
    }
    toString.setCharAt(toString.length()-2, ']');
    return toString.toString();
}
0
Parasouramane D

Ich habe diese kleine Klasse erstellt, mit der jedes Wort in einem Satz kapituliert werden kann. Sie können das Worttrennzeichen in der Zeichenfolge ändern, wenn dies kein Leerzeichen ist.

package com.ecnews.ecnews_v01.Helpers;

  public class Capitalize {

  String sentence;
  String separator = " ";

  public Capitalize(String sentence) {
    this.sentence = sentence;
  }

  public void setSeparator(String separator) {
    this.separator = separator;
  }

  public String getCapitalized() {
    StringBuilder capitalized = new StringBuilder("");
    for (String Word : sentence.split(separator)) {
        capitalized.append(separator+Character.toUpperCase(Word.charAt(0)) + Word.substring(1));
    }
    return capitalized.toString().trim();
  }

}

Beispiel:

String sourceName = new Capitalize("this is a test").getCapitalized();

sourceName lautet "Dies ist ein Test"

0

dies ist eine andere Art und Weise, die ich getan habe

    StringBuilder str=new StringBuilder("pirai sudie test test");

    str.setCharAt(0,Character.toUpperCase(str.charAt(0)));

    for(int i=str.length()-1;i>=0;i--)
    {
        if(Character.isSpaceChar(str.charAt(i)))
            str.setCharAt(i+1,Character.toUpperCase(str.charAt(i+1)));
    }

    System.out.println(str);
0
Pirai Sudie
public static void main(String[] args) throws IOException {
    String words = "this is a test";

    System.out.println(Arrays.asList(words.split(" ")).stream().reduce("",(a, b)->(a + " " + b.substring(0, 1).toUpperCase() + b.substring(1))));


}

}

0
C. Solarte

Hier streben wir eine perfekte Großschreibung von Word an

public static void main(String[] args) {
    String input ="my name is ranjan";
    String[] inputArr = input.split(" ");

    for(String Word : inputArr) {
        System.out.println(Word.substring(0, 1).toUpperCase()+Word.substring(1,Word.length()));
    }   
}

}

// Ausgabe: Mein Name ist Ranjan

0
Ranjan
Simple answer by program:


public class StringCamelCase {
    public static void main(String[] args) {
        String[] articles = {"the ", "a ", "one ", "some ", "any "};
        String[] result = new String[articles.length];
        int i = 0;
        for (String string : articles) {
            result[i++] = toUpercaseForstChar(string);
        }

        for (String string : result) {
            System.out.println(string);
        }
    }
    public static String toUpercaseForstChar(String string){
        return new String(new char[]{string.charAt(0)}).toUpperCase() + string.substring(1,string.length());
    }
}
0
Pankaj Sonagara

Hier ist die Kotlin-Version desselben Problems:

fun capitalizeFirstLetterOfEveryWord(text: String): String
{
    if (text.isEmpty() || text.isBlank())
    {
        return ""
    }

    if (text.length == 1)
    {
        return Character.toUpperCase(text[0]).toString()
    }

    val textArray = text.split(" ")
    val stringBuilder = StringBuilder()

    for ((index, item) in textArray.withIndex())
    {
        // If item is empty string, continue to next item
        if (item.isEmpty())
        {
            continue
        }

        stringBuilder
            .append(Character.toUpperCase(item[0]))

        // If the item has only one character then continue to next item because we have already capitalized it.
        if (item.length == 1)
        {
            continue
        }

        for (i in 1 until item.length)
        {
            stringBuilder
                .append(Character.toLowerCase(item[i]))
        }

        if (index < textArray.lastIndex)
        {
            stringBuilder
                .append(" ")
        }
    }

    return stringBuilder.toString()
}
0
Bugs Happen