it-swarm.com.de

Wie schreibe ich den ersten Buchstaben eines Strings in Java?

Ich verwende Java, um eine String-Eingabe vom Benutzer zu erhalten. Ich versuche, den ersten Buchstaben dieser Eingabe groß zu machen. 

Ich habe das versucht:

String name;

BufferedReader br = new InputStreamReader(System.in);

String s1 = name.charAt(0).toUppercase());

System.out.println(s1 + name.substring(1));

was zu diesen Compiler-Fehlern führte:

  • Typenkonflikt: Konvertierung von InputStreamReader in BufferedReader nicht möglich

  • ToUppercase () kann nicht für den primitiven Typ char aufgerufen werden

199
sumithra
String str = "Java";
String cap = str.substring(0, 1).toUpperCase() + str.substring(1);
// cap = "Java"

Mit deinem Beispiel:

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    // Actually use the Reader
    String name = br.readLine();
    // Don't mistake String object with a Character object
    String s1 = name.substring(0, 1).toUpperCase();
    String nameCapitalized = s1 + name.substring(1);
    System.out.println(nameCapitalized);
}
293
Rekin
160
Bozho

Der kürzere/schnellere Versionscode, um den ersten Buchstaben eines Strings groß zu schreiben, lautet:

String name  = "stackoverflow"; 
name = name.substring(0,1).toUpperCase() + name.substring(1).toLowerCase();

der Wert von name ist "Stackoverflow"

58
Elenasys

Verwenden Sie die allgemeine Bibliothek von Apache. Befreien Sie Ihr Gehirn von diesen Dingen und vermeiden Sie Null-Zeiger und Index-Out-of-Bound-Ausnahmen

Schritt 1:

Importieren Sie die Common lang-Bibliothek von Apache, indem Sie diese in build.gradle-Abhängigkeiten angeben

compile 'org.Apache.commons:commons-lang3:3.6'

Schritt 2:

Wenn Sie sicher sind, dass Ihre Zeichenfolge nur aus Kleinbuchstaben besteht, oder wenn Sie nur den ersten Buchstaben initialisieren möchten, rufen Sie direkt an

StringUtils.capitalize(yourString);

Wenn Sie sicherstellen möchten, dass nur der erste Buchstabe großgeschrieben wird (beispielsweise für eine enum), rufen Sie zuerst toLowerCase() auf. Denken Sie daran, dass NullPointerException ausgegeben wird, wenn die Eingabezeichenfolge null ist.

StringUtils.capitalize(YourEnum.STUFF.name().toLowerCase());
StringUtils.capitalize(yourString.toLowerCase());

Hier sind weitere Beispiele von Apache. es ist ausnahme frei

StringUtils.capitalize(null)  = null
StringUtils.capitalize("")    = ""
StringUtils.capitalize("cat") = "Cat"
StringUtils.capitalize("cAt") = "CAt"
StringUtils.capitalize("'cat'") = "'cat'"

Hinweis:

WordUtils ist ebenfalls in dieser Bibliothek enthalten, aber veraltet. Bitte nicht benutze das.

28
Fangming

Was Sie wollen, ist wahrscheinlich folgendes:

s1 = name.substring(0, 1).toUpperCase() + name.substring(1);

(wandelt das erste Zeichen in Großbuchstaben um und fügt den Rest der ursprünglichen Zeichenfolge hinzu)

Sie erstellen auch einen Eingabestromleser, lesen jedoch niemals eine Zeile. name ist also immer null.

Das sollte funktionieren:

BufferedReader br = new InputstreamReader(System.in);
String name = br.readLine();
String s1 = name.substring(0, 1).toUpperCase() + name.substring(1);
19
Grodriguez
14
Zaki

Die untenstehende Lösung wird funktionieren.

String A = "stackOverflow";
String ACaps = A.toUpperCase().charAt(0)+A.substring(1,A.length());
//Will print StackOverflow

ToUpperCase () kann nicht für primitive Zeichen verwendet werden. Sie können jedoch zuerst den gesamten String in Großbuchstaben schreiben, dann das erste Zeichen verwenden und dann wie oben gezeigt an den Teilstring anhängen.

11
8
Suresh Kumar

Am kürzesten auch:

String message = "my message";    
message = Character.toUpperCase(message.charAt(0)) + message.substring(1);
System.out.println(message)    // Will output: My message

Arbeitete für mich.

5
Dassi Orleando
String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);
5
Aditya Parmar

Setzen Sie die Zeichenfolge auf Kleinbuchstaben, und setzen Sie den ersten Buchstaben so auf Upper:

    userName = userName.toLowerCase();

dann den ersten Buchstaben groß zu schreiben:

    userName = userName.substring(0, 1).toUpperCase() + userName.substring(1).toLowerCase();

substring ist nur ein Stück einer größeren Saite, dann kombinieren wir sie wieder zusammen.

5
AlexZeCoder

In Android Studio

Fügen Sie diese Abhängigkeit zu Ihrer build.gradle (Module: app) hinzu.

dependencies {
    ...
    compile 'org.Apache.commons:commons-lang3:3.1'
    ...
}

Jetzt können Sie verwenden

String string = "STRING WITH ALL CAPPS AND SPACES";

string = string.toLowerCase(); // Make all lowercase if you have caps

someTextView.setText(WordUtils.capitalize(string));
4
Michael

Sie können substring() verwenden, um dies zu tun. 

Es gibt jedoch zwei verschiedene Fälle:

Fall 1

Wenn die String, die Sie groß schreiben, für Menschen lesbar sein soll, sollten Sie auch das Standardgebietsschema angeben:

String firstLetterCapitalized = 
    myString.substring(0, 1).toUpperCase(Locale.getDefault()) + myString.substring(1);

Fall 2

Wenn die String, die Sie aktivieren, maschinenlesbar sein soll, sollten Sie Locale.getDefault() nicht verwenden, da die zurückgegebene Zeichenfolge in verschiedenen Regionen inkonsistent ist. Geben Sie in diesem Fall immer dasselbe Gebietsschema an (beispielsweise toUpperCase(Locale.ENGLISH)). Dadurch wird sichergestellt, dass die Zeichenfolgen, die Sie für die interne Verarbeitung verwenden, konsistent sind, wodurch Sie schwer zu findende Fehler vermeiden können.

Hinweis: Sie müssen Locale.getDefault() nicht für toLowerCase() angeben, da dies automatisch erfolgt.

4
JDJ

Was ist mit WordUtils.capitalizeFully () ?

import org.Apache.commons.lang3.text.WordUtils;

public class Main {

    public static void main(String[] args) {

        final String str1 = "HELLO WORLD";
        System.out.println(capitalizeFirstLetter(str1)); // output: Hello World

        final String str2 = "Hello WORLD";
        System.out.println(capitalizeFirstLetter(str2)); // output: Hello World

        final String str3 = "hello world";
        System.out.println(capitalizeFirstLetter(str3)); // output: Hello World

        final String str4 = "heLLo wORld";
        System.out.println(capitalizeFirstLetter(str4)); // output: Hello World
    }

    private static String capitalizeFirstLetter(String str) {
        return WordUtils.capitalizeFully(str);
    }
}
4
Arpit

probier diese

Was diese Methode tut, ist das, denke das Wort "Hallo Welt". Diese Methode macht es zu "Hallo Welt".

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

    }
3
Ameen Maheen

Das soll Ihnen nur zeigen, dass Sie sich nicht so geirrt haben.

BufferedReader br = new InputstreamReader(System.in);
// Assuming name is not blank
String name = br.readLine(); 

//No more error telling that you cant convert char to string
String s1 = (""+name.charAt(0)).toUppercase());
// Or, as Carlos prefers. See the comments to this post.
String s1 = Character.toString(name.charAt(0)).toUppercase());

System.out.println(s1+name.substring(1));

Hinweis: Dies ist überhaupt nicht der beste Weg, dies zu tun. Dies soll nur dem OP zeigen, dass es auch mit charAt() möglich ist. ;)

3
Adeel Ansari
Use this utility method to get all first letter in capital. 


String captializeAllFirstLetter(String name) 
    {
        char[] array = name.toCharArray();
        array[0] = Character.toUpperCase(array[0]);

        for (int i = 1; i < array.length; i++) {
            if (Character.isWhitespace(array[i - 1])) {
                array[i] = Character.toUpperCase(array[i]);
            }
        }

        return new String(array);
    }
2
Krrish

Schauen Sie sich ACL WordUtils an.

WordUtils.capitalize ("Ihre Zeichenfolge") == "Ihre Zeichenfolge"

Wie schreibe ich jeden ersten Buchstaben von Word in einer Zeichenfolge?

2
Manoj Ekanayaka
public static String capitalizer(final String texto) {

    // split words
    String[] palavras = texto.split(" ");
    StringBuilder sb = new StringBuilder();

    // list of Word exceptions
    List<String> excessoes = new ArrayList<String>(Arrays.asList("de", "da", "das", "do", "dos", "na", "nas", "no", "nos", "a", "e", "o", "em", "com"));

    for (String palavra : palavras) {

        if (excessoes.contains(palavra.toLowerCase()))
            sb.append(palavra.toLowerCase()).append(" ");
        else
            sb.append(Character.toUpperCase(palavra.charAt(0))).append(palavra.substring(1).toLowerCase()).append(" ");
    }
    return sb.toString().trim();
}
2
Doc Brown

Bei den angegebenen Antworten wird nur der erste Buchstabe eines Wortes großgeschrieben. Verwenden Sie den folgenden Code, um eine ganze Zeichenfolge in Großbuchstaben zu schreiben.

public static void main(String[] args) {
    String str = "this is a random string";
    StringBuilder capitalizedString = new StringBuilder();
    String[] splited = str.trim().split("\\s+");

    for (String string : splited) {         
        String s1 = string.substring(0, 1).toUpperCase();
        String nameCapitalized = s1 + string.substring(1);

        capitalizedString.append(nameCapitalized);
        capitalizedString.append(" ");
    }
    System.out.println(capitalizedString.toString().trim());
}

ausgabe: This Is A Random String

2
Vimukthi_R

Sie können dies auch versuchen:

 String s1 = br.readLine();
 char[] chars = s1.toCharArray();
 chars[0] = Character.toUpperCase(chars[0]);
 s1= new String(chars);
 System.out.println(s1);

Dies ist besser (optimiert) als bei der Verwendung von Teilzeichenfolge. (aber keine Sorge um kleine Schnur)

2
jerjer

Das wird funktionieren

char[] array = value.toCharArray();

array[0] = Character.toUpperCase(array[0]);

String result = new String(array);
2
System.out.println(Character.toString(A.charAt(0)).toUpperCase()+A.substring(1));

P.S = a ist eine Zeichenfolge.

1
Germa Vinsmoke

Sie können den folgenden Code verwenden:

public static String capitalizeString(String string) {

    if (string == null || string.trim().isEmpty()) {
        return string;
    }
    char c[] = string.trim().toLowerCase().toCharArray();
    c[0] = Character.toUpperCase(c[0]);

    return new String(c);

}

beispieltest mit JUnit: 

@Test
public void capitalizeStringUpperCaseTest() {

    String string = "HELLO WORLD  ";

    string = capitalizeString(string);

    assertThat(string, is("Hello world"));
}

@Test
public void capitalizeStringLowerCaseTest() {

    String string = "hello world  ";

    string = capitalizeString(string);

    assertThat(string, is("Hello world"));
}

Um das erste Zeichen eines jeden Wortes in einer Zeichenfolge groß zu schreiben,

zuerst müssen Sie jedes Wort dieser Zeichenfolge & für diese aufgeteilte Zeichenfolge abrufen, in der ein Leerzeichen vorhanden ist, indem Sie die unten beschriebene Teilungsmethode verwenden und jedes Wort in einem Array speichern. Erstellen Sie dann eine leere Zeichenfolge. Danach holen Sie sich mit der substring () - Methode das erste Zeichen und das verbleibende Zeichen des entsprechenden Words und speichern Sie sie in zwei verschiedenen Variablen.

Dann mit der toUpperCase () - Methode das erste Zeichen groß schreiben und die verbleibenden Zeichen wie folgt zu dieser leeren Zeichenfolge hinzufügen.

public class Test {  
     public static void main(String[] args)
     {
         String str= "my name is khan";        // string
         String words[]=str.split("\\s");      // split each words of above string
         String capitalizedWord = "";         // create an empty string

         for(String w:words)
         {  
              String first = w.substring(0,1);    // get first character of each Word
              String f_after = w.substring(1);    // get remaining character of corresponding Word
              capitalizedWord += first.toUpperCase() + f_after+ " ";  // capitalize first character and add the remaining to the empty string and continue
         }
         System.out.println(capitalizedWord);    // print the result
     }
}
1
Dev d

Mit dem von mir geposteten Code werden das Unterstreichungszeichen (_) und zusätzliche Leerzeichen aus String entfernt. Außerdem wird der erste Buchstabe jedes neuen Wortes in String groß geschrieben

private String capitalize(String txt){ 
  List<String> finalTxt=new ArrayList<>();

  if(txt.contains("_")){
       txt=txt.replace("_"," ");
  }

  if(txt.contains(" ") && txt.length()>1){
       String[] tSS=txt.split(" ");
       for(String tSSV:tSS){ finalTxt.add(capitalize(tSSV)); }  
  }

  if(finalTxt.size()>0){
       txt="";
       for(String s:finalTxt){ txt+=s+" "; }
  }

  if(txt.endsWith(" ") && txt.length()>1){
       txt=txt.substring(0, (txt.length()-1));
       return txt;
  }

  txt = txt.substring(0,1).toUpperCase() + txt.substring(1).toLowerCase();
  return txt;
}
1
Shehroz

Eine der Antworten war zu 95% korrekt, aber bei meiner unitTest @Ameen Maheens Lösung war die Lösung nahezu perfekt. Außer dass die Eingabe in ein String-Array konvertiert wird, müssen Sie die Eingabe trimmen. Also der perfekte:

private String convertStringToName(String name) {
        name = name.trim();
        String[] words = name.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
crix

Sie können den folgenden Code verwenden:

public static void main(String[] args) {

    capitalizeFirstLetter("Java");
    capitalizeFirstLetter("Java developer");
}

public static void capitalizeFirstLetter(String text) {

    StringBuilder str = new StringBuilder();

    String[] tokens = text.split("\\s");// Can be space,comma or hyphen

    for (String token : tokens) {
        str.append(Character.toUpperCase(token.charAt(0))).append(token.substring(1)).append(" ");
    }
    str.toString().trim(); // Trim trailing space

    System.out.println(str);

}
1
Mulalo Madida

Viele der Antworten sind sehr hilfreich. Daher habe ich eine Methode erstellt, mit der aus einer beliebigen Zeichenfolge ein Titel erstellt werden kann.

static String toTitle (String s) {
      String s1 = s.substring(0,1).toUpperCase();
      String sTitle = s1 + s.substring(1);
      return sTitle;
 }
1
Nooblhu

Ein Ansatz.

String input = "someТекст$T%$4čřЭ"; //Enter your text.
if (input == null || input.isEmpty()) {
    return "";
}

char [] chars = input.toCharArray();
chars[0] = chars[0].toUpperCase();
String res = new String(chars);
return res;

Der Nachteil dieser Methode besteht darin, dass Sie, wenn inputString lang ist, drei Objekte dieser Länge haben. Das gleiche wie du

String s1 = input.substring(1).toUpperCase();
String s2 = input.substring(1, lenght);
String res = s1 + s2;

Oder auch

//check if not null.
StringBuilder buf = new StringBuilder(input);
char ch = buf.getCharAt(0).toUpperCase();
buf.setCharAt(0, ch);
return buf.toString();
0
Yan Khonski

Verwenden Sie die Ersetzungsmethode.

String newWord = Word.replace(String.valueOf(Word.charAt(0)), String.valueOf(Word.charAt(0)).toUpperCase());
0
Engine
public void capitalizeFirstLetter(JTextField textField) {

    try {

        if (!textField.getText().isEmpty()) {
            StringBuilder b = new StringBuilder(textField.getText());
            int i = 0;
            do {
                b.replace(i, i + 1, b.substring(i, i + 1).toUpperCase());
                i = b.indexOf(" ", i) + 1;
            } while (i > 0 && i < b.length());
            textField.setText(b.toString());
        }

    } catch (Exception e) {
        e.printStackTrace();
        JOptionPane.showMessageDialog(null, e, "Error", JOptionPane.ERROR_MESSAGE);
    }
}
0
Suresh

Dieser Code, um jedes Wort im Text groß zu schreiben!

public String capitalizeText(String name) {
    String[] s = name.trim().toLowerCase().split("\\s+");
    name = "";
    for (String i : s){
        if(i.equals("")) return name; // or return anything you want
        name+= i.substring(0, 1).toUpperCase() + i.substring(1) + " "; // uppercase first char in words
    }
    return name.trim();
}
0
An Van Nguyen

Sie können Class WordUtils verwenden.

Angenommen, Ihr String ist "aktuelle Adresse" und wird dann verwendet 

**** starker textWordutils.capitaliz (String); Ausgabe: Aktuelle Adresse

Siehe: http://commons.Apache.org/proper/commons-lang/apidocs/org/Apache/commons/lang3/text/WordUtils.html

0
SANDEEP KIRWAI

Sie können dies versuchen

/**
 * capitilizeFirst(null)  -> ""
 * capitilizeFirst("")    -> ""
 * capitilizeFirst("   ") -> ""
 * capitilizeFirst(" df") -> "Df"
 * capitilizeFirst("AS")  -> "As"
 *
 * @param str input string
 * @return String with the first letter capitalized
 */
public String capitilizeFirst(String str)
{
    // assumptions that input parameter is not null is legal, as we use this function in map chain
    Function<String, String> capFirst = (String s) -> {
        String result = ""; // <-- accumulator

        try { result += s.substring(0, 1).toUpperCase(); }
        catch (Throwable e) {}
        try { result += s.substring(1).toLowerCase(); }
        catch (Throwable e) {}

        return result;
    };

    return Optional.ofNullable(str)
            .map(String::trim)
            .map(capFirst)
            .orElse("");
}
0
R. Gordeev

vielen Dank, ich habe einige Kommentare gelesen und bin mit folgendem gekommen 

public static void main(String args[]) 
{
String myName = "nasser";
String newName = myName.toUpperCase().charAt(0) +  myName.substring(1);
System.out.println(newName );
}

Ich hoffe, es hilft. Viel Glück 

0
Nasser Al kaabi

Von commons.lang.StringUtils ist die beste Antwort: 

public static String groß (String str) {
int strLen;
return str! = null && (strLen = str.length ())! = 0? (new StringBuffer (strLen)). append (Character.toTitleCase (str.charAt (0))). append (str.substring (1)). toString (): str;
}

ich finde es toll, da es die Zeichenfolge mit einem StringBuffer umgibt. Sie können den StringBuffer beliebig bearbeiten, indem Sie dieselbe Instanz verwenden.

0
velocity

Jorgesys-Code wurde gerade überarbeitet und einige Checks hinzugefügt wegen einiger Fälle, die sich auf die Stringlänge beziehen. Machen Sie in meinem Fall keine Nullreferenzprüfung.

 public static String capitalizeFirstLetter(@NonNull String customText){
        int count = customText.length();
        if (count == 0) {
            return customText;
        }
        if (count == 1) {
            return customText.toUpperCase();
        }
        return customText.substring(0, 1).toUpperCase() + customText.substring(1).toLowerCase();
    }
0
Ruslan Podurets

Die Antwort von Ameen Mahheen ist gut, aber wenn wir eine Zeichenfolge mit doppeltem Leerzeichen haben, wie "Hallo Welt", dann erhält sb.append die IndexOutOfBounds-Ausnahme. Das Richtige ist, teste vor dieser Zeile:

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(" ");
                if (words[i].length() > 0) sb.append(Character.toUpperCase(words[i].charAt(0)) + words[i].subSequence(1, words[i].length()).toString().toLowerCase());
            }
        }
        return  sb.toString();
    }
0
Raphael Moraes

Ein weiteres Beispiel, wie Sie den ersten Buchstaben der Benutzereingabe in Großbuchstaben setzen können:

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String string = br.readLine();
// handle supplementary characters
IntStream.concat(
        IntStream.of(string.codePointAt(0))
                .map(Character::toUpperCase), string.codePoints().skip(1)
)
.forEach(cp -> System.out.print(Character.toChars(cp)));
0
Aleksey Bykov
class CapitalizeWords
{
    public static void main(String[] args) 
    {
        String input ="welcome to kashmiri geeks...";

        System.out.println(input);

        String[] str = input.split(" ");

        for(int i=0; i< str.length; i++)
        {
            str[i] = (str[i]).substring(0,1).toUpperCase() + (str[i]).substring(1);
        }

        for(int i=0;i<str.length;i++)
        {
            System.out.print(str[i]+" ");
        }


    }
}
0
Maahi bhat

Für Java-Benutzer:

einfach eine Erweiterung um jede Zeichenkette groß zu machen.

public static capitalize(String str)
{
    return this.substring(0, 1).toUpperCase() + this.substring(1)
}

Rufen Sie danach einfach str = capitalize(str) auf.

Für Kotlin-Benutzer rufen Sie einfach an:

str.capitalize()

Im folgenden Beispiel werden Wörter auch nach Sonderzeichen wie [/ -] großgeschrieben.

  public static String capitalize(String text) {
    char[] stringArray = text.trim().toCharArray();
    boolean wordStarted = false;
    for( int i = 0; i < stringArray.length; i++) {
      char ch = stringArray[i];
      if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '\'') {
        if( !wordStarted ) {
          stringArray[i] = Character.toUpperCase(stringArray[i]);
          wordStarted = true;
        } 
      } else {
        wordStarted = false;
      }
    }
    return new String(stringArray);
  }

Example:
capitalize("that's a beautiful/wonderful life we have.We really-do")

Output:
That's A Beautiful/Wonderful Life We Have.We Really-Do
0
Delorean

Wenn Input UpperCase ist, dann verwende folgendes:

strString (0, 1) .toUpperCase () + StrString (1) .toLowerCase ();

Wenn Input LowerCase ist, dann verwende folgendes:

strString (0, 1) .toUpperCase () + StrString (1);

0
Raj Kumar
import Java.util.*;
public class Program
{
    public static void main(String[] args) 
      {
        Scanner sc=new Scanner(System.in);
        String s1=sc.nextLine();
        String[] s2=s1.split(" ");//***split text into words***
        ArrayList<String> l = new ArrayList<String>();//***list***
        for(String w: s2)
        l.add(w.substring(0,1).toUpperCase()+w.substring(1)); 
        //***converting 1st letter to capital and adding to list***
        StringBuilder sb = new StringBuilder();//***i used StringBuilder to convert words to text*** 
        for (String s : l)
          {
             sb.append(s);
             sb.append(" ");
          }
      System.out.println(sb.toString());//***to print output***
      }
}

ich habe die Split-Funktion verwendet, um die Zeichenfolge in Wörter zu teilen. Dann habe ich die Liste verwendet, um die ersten Großbuchstaben in diesen Wörtern zu erhalten. Dann habe ich den String-Builder verwendet, um die Ausgabe im String-Format mit Leerzeichen darin zu drucken

0
Sindhu Adapa
String s = "first second third fourth";

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

            if ((s.substring(j, i).endsWith(" "))) {

                String s2 = s.substring(j, i);
                System.out.println(Character.toUpperCase(s.charAt(j))+s2.substring(1));
                j = i;
            }
        }
        System.out.println(Character.toUpperCase(s.charAt(j))+s.substring(j+1));
0
emre hamurcu