Jak zamienić pierwszą literę słowa w ciągu za pomocą Java?

Przykładowe ciągi

one thousand only
two hundred
twenty
seven

Jak zmienić pierwszy znak ciągu wielką literą i nie zmieniać wielkości liter w pozostałych literach?

Po zmianie powinno być:

One thousand only
Two hundred
Twenty
Seven

Uwaga: nie chcę używać do tego apache.commons.lang.WordUtils.

Jeśli chcesz tylko wpisać pierwszą literę ciągu o nazwie, inputa resztę pozostaw w spokoju:

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

Teraz outputbędziesz mieć to, czego chcesz. inputPrzed użyciem tej opcji sprawdź, czy masz przynajmniej jedną postać, w przeciwnym razie otrzymasz wyjątek.

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

Po prostu ... kompletne rozwiązanie, widzę, że po prostu połączyło to, co wszyscy skończyli pisać = P.

Najprostszym sposobem jest użycie org.apache.commons.lang.StringUtilsklasy

StringUtils.capitalize(Str);

Ponadto istnieje org.springframework.util.StringUtilsw Spring Framework :

StringUtils.capitalize(str);

StringUtils.capitalize(str)

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

Proszę bardzo (mam nadzieję, że to da ci pomysł):

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

}

Potrzebny jest do tego tylko jeden kod linii. jeśli String A = scanner.nextLine(); to musisz napisać, aby wyświetlić ciąg z wielką literą pierwszej litery.

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

I gotowe.

Przykład użycia klasy StringTokenizer:

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

Rozwiązanie z StringBuilder:

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

.. na podstawie poprzednich odpowiedzi

Łącząc wszystko razem, dobrym pomysłem jest przycięcie, aby uzyskać dodatkowe białe znaki na początku sznurka. W przeciwnym razie .substring (0,1) .toUpperCase spróbuje wpisać wielką spację.

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

Moje funkcjonalne podejście. jego pierwszy znak w zdaniu po whitescape w całym akapicie.

Aby wykorzystać tylko pierwszy znak tego słowa, wystarczy usunąć .split („”)

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

Zaktualizuj lipiec 2019 r

Obecnie najbardziej aktualna funkcja biblioteczna do tego celu znajduje się w org.apache.commons.lang3.StringUtils

import org.apache.commons.lang3.StringUtils;

StringUtils.capitalize(myString);

Jeśli używasz Maven, zaimportuj zależność do pliku pom.xml:

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

Nawet w przypadku „prostego” kodu korzystałbym z bibliotek. Nie chodzi o sam kod, ale o istniejące przypadki testowe obejmujące wyjątkowe przypadki. Mogą to być nullpuste ciągi, ciągi w innych językach.

Część manipulacji słowami została przeniesiona z Apache Commons Lang. Teraz jest umieszczony w tekście Apache Commons . Pobierz za pośrednictwem https://search.maven.org/artifact/org.apache.commons/commons-text .

Możesz użyć WordUtils.capitalize (String str) z Apache Commons Text. Jest silniejszy niż prosiłeś. Może także używać wielkich liter (np. Utrwalania "oNe tousand only").

Ponieważ działa na pełnym tekście, należy powiedzieć mu, aby użyła tylko pierwszego słowa.

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

Pełna klasa JUnit, aby umożliwić grę z funkcjonalnością:

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

}

jeśli chcesz tylko wpisać wielką literę, możesz użyć poniższego kodu

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

W rzeczywistości uzyskasz najlepszą wydajność, jeśli unikniesz +operatora i użyjesz go concat()w tym przypadku. Jest to najlepsza opcja do łączenia tylko 2 łańcuchów (choć nie tak dobra dla wielu łańcuchów). W takim przypadku kod wyglądałby tak:

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

Użyj tego:

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

Biorąc pod uwagę inputciąg:

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

Możesz wypróbować następujący kod:

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

Chciałbym dodać czek NULL i IndexOutOfBoundsException do zaakceptowanej odpowiedzi.

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

Kod Java:

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

Wynik:

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]

Poniższe daje ci takie same spójne dane wyjściowe niezależnie od wartości Twojego inputString:

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

1. Przy użyciu substring()metody String

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

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

Teraz wystarczy wywołać capitalize()metodę, aby przekonwertować pierwszą literę ciągu na wielkie litery:

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

2. Apache Commons Lang

StringUtilsKlasa z Commons Lang dostarcza capitalize()sposobu, który może być również używany do tego celu:

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

Dodaj następującą zależność do swojego pom.xmlpliku (tylko dla Maven):

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

Oto artykuł, który szczegółowo wyjaśnia te dwa podejścia.

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