Wie kann man den ersten Buchstaben eines Wortes in einer Zeichenfolge mit Java groß schreiben?

Beispielzeichenfolgen

one thousand only
two hundred
twenty
seven

Wie ändere ich das erste Zeichen einer Zeichenfolge in Großbuchstaben und nicht die Groß- und Kleinschreibung der anderen Buchstaben?

Nach der Änderung sollte es sein:

One thousand only
Two hundred
Twenty
Seven

Hinweis: Ich möchte dazu nicht apache.commons.lang.WordUtils verwenden.

Wenn Sie nur den ersten Buchstaben einer Zeichenfolge mit dem Namen groß schreiben inputund den Rest in Ruhe lassen möchten :

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

Jetzt outputhaben Sie, was Sie wollen. Überprüfen Sie, ob Ihr inputZeichen mindestens ein Zeichen ist, bevor Sie dies verwenden. Andernfalls wird eine Ausnahme angezeigt.

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

Nur ... eine Komplettlösung, ich sehe, dass sie sozusagen das kombiniert hat, was alle anderen am Ende gepostet haben = P.

Am einfachsten ist es, org.apache.commons.lang.StringUtilsKlasse zu verwenden

StringUtils.capitalize(Str);

Außerdem gibt es org.springframework.util.StringUtilsim Frühjahr Framework :

StringUtils.capitalize(str);

StringUtils.capitalize(str)

von apache commons-lang .

String sentence = "ToDAY   WeAthEr   GREat";    
public static String upperCaseWords(String sentence) {
        String words[] = sentence.replaceAll("\\s+", " ").trim().split(" ");
        String newSentence = "";
        for (String word : words) {
            for (int i = 0; i < word.length(); i++)
                newSentence = newSentence + ((i == 0) ? word.substring(i, i + 1).toUpperCase(): 
                    (i != word.length() - 1) ? word.substring(i, i + 1).toLowerCase() : word.substring(i, i + 1).toLowerCase().toLowerCase() + " ");
        }

        return newSentence;
    }
//Today Weather Great

String s=t.getText().trim();
int l=s.length();
char c=Character.toUpperCase(s.charAt(0));
s=c+s.substring(1);
for(int i=1; i<l; i++)
    {
        if(s.charAt(i)==' ')
        {
            c=Character.toUpperCase(s.charAt(i+1));
            s=s.substring(0, i) + c + s.substring(i+2);
        }
    }
    t.setText(s);

Los geht's (hoffe, das bringt dich auf die Idee):

/*************************************************************************
 *  Compilation:  javac Capitalize.java
 *  Execution:    java Capitalize < input.txt
 * 
 *  Read in a sequence of words from standard input and capitalize each
 *  one (make first letter uppercase; make rest lowercase).
 *
 *  % java Capitalize
 *  now is the time for all good 
 *  Now Is The Time For All Good 
 *  to be or not to be that is the question
 *  To Be Or Not To Be That Is The Question 
 *
 *  Remark: replace sequence of whitespace with a single space.
 *
 *************************************************************************/

public class Capitalize {

    public static String capitalize(String s) {
        if (s.length() == 0) return s;
        return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
    }

    public static void main(String[] args) {
        while (!StdIn.isEmpty()) {
            String line = StdIn.readLine();
            String[] words = line.split("\\s");
            for (String s : words) {
                StdOut.print(capitalize(s) + " ");
            }
            StdOut.println();
        }
    }

}

Hierfür wird lediglich ein Zeilencode benötigt. In String A = scanner.nextLine(); diesem Fall müssen Sie dies schreiben, um die Zeichenfolge mit diesem Großbuchstaben anzuzeigen.

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

Und jetzt ist es geschafft.

Beispiel mit der StringTokenizer-Klasse:

String st = "  hello all students";
String st1;
char f;
String fs="";
StringTokenizer a= new StringTokenizer(st);
while(a.hasMoreTokens()){   
        st1=a.nextToken();
        f=Character.toUpperCase(st1.charAt(0));
        fs+=f+ st1.substring(1);
        System.out.println(fs);
} 

Lösung mit StringBuilder:

value = new StringBuilder()
                .append(value.substring(0, 1).toUpperCase())
                .append(value.substring(1))
                .toString();

.. basierend auf vorherigen Antworten

Wenn Sie alles zusammenzählen, ist es eine gute Idee, am Anfang der Saite zusätzlichen Leerraum zu schneiden. Andernfalls versucht .substring (0,1) .toUpperCase, einen Leerraum groß zu schreiben.

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

Mein funktionaler Ansatz. sein capstilise erstes Zeichen im Satz nach whitescape im ganzen Absatz.

Um nur das erste Zeichen des Wortes zu kapatilisieren, entfernen Sie einfach .split ("").

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

Update Juli 2019

Derzeit ist die aktuellste Bibliotheksfunktion dafür enthalten org.apache.commons.lang3.StringUtils

import org.apache.commons.lang3.StringUtils;

StringUtils.capitalize(myString);

Wenn Sie Maven verwenden, importieren Sie die Abhängigkeit in Ihre pom.xml:

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

Selbst für "einfachen" Code würde ich Bibliotheken verwenden. Es geht nicht um den Code an sich, sondern um die bereits vorhandenen Testfälle, die Ausnahmefälle abdecken. Dies können nullleere Zeichenfolgen sein, Zeichenfolgen in anderen Sprachen.

Der Wortmanipulationsteil wurde aus Apache Commons Lang entfernt. Es ist jetzt in Apache Commons Text platziert . Erhalten Sie es über https://search.maven.org/artifact/org.apache.commons/commons-text .

Sie können WordUtils.capitalize (String str) aus Apache Commons Text verwenden. Es ist mächtiger als Sie verlangt haben. Es kann auch Fulle groß schreiben (z "oNe tousand only". B. Fixieren ).

Da es mit vollständigem Text funktioniert, muss man ihm sagen, dass nur das erste Wort groß geschrieben werden soll.

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

Vollständige JUnit-Klasse, um das Spielen mit der Funktionalität zu ermöglichen:

package io.github.koppor;

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

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

class AppTest {

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

}

Wenn Sie nur den ersten Buchstaben groß schreiben möchten, kann der folgende Code verwendet werden

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

Tatsächlich erzielen Sie die beste Leistung, wenn Sie den +Bediener meiden und concat()in diesem Fall verwenden. Dies ist die beste Option zum Zusammenführen von nur 2 Zeichenfolgen (für viele Zeichenfolgen jedoch nicht so gut). In diesem Fall würde der Code folgendermaßen aussehen:

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

Benutze das:

char[] chars = {Character.toUpperCase(A.charAt(0)), 
Character.toUpperCase(B.charAt(0))};
String a1 = chars[0] + A.substring(1);
String b1 = chars[1] + B.substring(1);

Angesichts der inputZeichenfolge:

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

Sie können den folgenden Code ausprobieren:

public string capitalize(str) {
    String[] array = str.split(" ");
    String newStr;
    for(int i = 0; i < array.length; i++) {
        newStr += array[i].substring(0,1).toUpperCase() + array[i].substring(1) + " ";
    }
    return newStr.trim();
}

public static String capitalize(String str){
        String[] inputWords = str.split(" ");
        String outputWords = "";
        for (String word : inputWords){
            if (!word.isEmpty()){
                outputWords = outputWords + " "+StringUtils.capitalize(word);
            }
        }
        return outputWords;
    }

Ich möchte der akzeptierten Antwort eine NULL-Prüfung und eine IndexOutOfBoundsException hinzufügen.

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

Java Code:

  class Main {
      public static void main(String[] args) {
        System.out.println("Capitalize first letter ");
        System.out.println("Normal  check #1      : ["+ captializeFirstLetter("one thousand only")+"]");
        System.out.println("Normal  check #2      : ["+ captializeFirstLetter("two hundred")+"]");
        System.out.println("Normal  check #3      : ["+ captializeFirstLetter("twenty")+"]");
        System.out.println("Normal  check #4      : ["+ captializeFirstLetter("seven")+"]");

        System.out.println("Single letter check   : ["+captializeFirstLetter("a")+"]");
        System.out.println("IndexOutOfBound check : ["+ captializeFirstLetter("")+"]");
        System.out.println("Null Check            : ["+ captializeFirstLetter(null)+"]");
      }

      static String captializeFirstLetter(String input){
             if(input!=null && input.length() >0){
                input = input.substring(0, 1).toUpperCase() + input.substring(1);
            }
            return input;
        }
    }

Ausgabe:

Normal  check #1      : [One thousand only]
Normal  check #2      : [Two hundred]
Normal  check #3      : [Twenty]
Normal  check #4      : [Seven]
Single letter check   : [A]
IndexOutOfBound check : []
Null Check            : [null]

Im Folgenden erhalten Sie unabhängig vom Wert Ihres inputString dieselbe konsistente Ausgabe:

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

1. Verwenden der String- substring()Methode

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

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

Rufen Sie jetzt einfach die capitalize()Methode auf, um den ersten Buchstaben einer Zeichenfolge in Großbuchstaben umzuwandeln:

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

2. Apache Commons Lang

Die StringUtilsKlasse von Commons Lang bietet die capitalize()Methode, die auch für diesen Zweck verwendet werden kann:

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

Fügen Sie Ihrer pom.xmlDatei die folgende Abhängigkeit hinzu (nur für Maven):

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

In diesem Artikel werden diese beiden Ansätze ausführlich erläutert.

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