Jak zapisać wielką literę ciągu w Javie?

305

Używam Java, aby uzyskać String wejściowe od użytkownika. Staram się, aby pierwsza litera tego wpisu była pisana wielkimi literami.

Próbowałem tego:

String name;

BufferedReader br = new InputStreamReader(System.in);

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

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

co doprowadziło do tych błędów kompilatora:

  • Niezgodność typu: nie można przekonwertować z InputStreamReader na BufferedReader

  • Nie można wywołać metody toUppercase () na pierwotnym typie char

sumithra
źródło
2
@Pontus - Nie zgadzam się. Dla wejścia „abcd” OP chce wyjścia „Abcd”. Wydaje się to dość jasne, chociaż pytanie mogłoby być lepsze.
Kobi
znak to prymitywny typ danych w Javie. Nie można wyrejestrować prymitywnego typu danych za pomocą operatora kropki (.). Musisz podciągnąć pierwszy znak według nazwy.substring (0,1);
Divakar Rajesh,

Odpowiedzi:

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

Na przykład:

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);
}
Rekin
źródło
1
Myślę, że potrzebujesz -1 po str.length (), w przeciwnym razie wyjdziesz poza granice.
dutt
@dutt: Nie, to też było w porządku. Ale modyfikacja Rekina sprawiła, że ​​była idealna. ;)
Adeel Ansari,
wspólny język jest zawsze lepszy niż pisanie własnej funkcji, z wyjątkiem rzadkich przypadków, w których znasz się lepiej. Jeśli nie poszedłeś przeczytać wspólnej dokumentacji języka Java w funkcji wielkich liter, nie powinieneś pisać własnej.
The.Laughing.Man
211

StringUtils.capitalize(..) z commons-lang

Bozho
źródło
Korzystałem z WordUtils, ma również tę samą funkcję, ale wielkie litery wszystkich słów w zdaniu.
Surbhit Rao
StringUtils.capitalize( "fred from jupiter" );produkuje "Fred from jupiter". Łatwe ...: D
udoline
WordUtils.capitalizeFully () działał dla mnie jak urok, ponieważ daje: WordUtils.capitalizeFully ("i am FINE") = "I Am Fine"
Atul Sharma
91

Krótszy / szybszy kod wersji, w którym pierwsza litera ciągu ma być wielka, to:

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

wartość namewynosi"Stackoverflow"

Jorgesys
źródło
4
Podoba mi się to rozwiązanie, ponieważ zapewnia, że ​​reszta ciągu ma małe litery. Właśnie tego potrzebowałem przy konwersji nazw enum ALL_CAPS.
Ellen Spertus,
54

Użyj wspólnej biblioteki Apache. Uwolnij swój mózg od tych rzeczy i unikaj wskaźnika zerowego i indeksu poza wyjątkami

Krok 1:

Zaimportuj wspólną bibliotekę języka apache, umieszczając ją w build.gradlezależnościach

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

Krok 2:

Jeśli masz pewność, że ciąg jest pisany małymi literami, lub wystarczy zainicjować pierwszą literę, zadzwoń bezpośrednio

StringUtils.capitalize(yourString);

Jeśli chcesz się upewnić, że tylko pierwsza litera jest pisana wielkimi literami, na przykład rób to enum, toLowerCase()najpierw zadzwoń i pamiętaj, że wyrzuci, NullPointerExceptionjeśli łańcuch wejściowy jest pusty.

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

Oto więcej próbek dostarczonych przez apache. jest wolny od wyjątków

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

Uwaga:

WordUtilsjest również zawarty w tej bibliotece, ale jest przestarzały. Proszę tego nie używać.

Fangming
źródło
2
Dzięki. Nie mogę uwierzyć, że ludzie nawet myślą o użyciu pętli for do tego rodzaju zadań
Alvaro,
@Alvaro, na koniec dnia - ludzie używają pętli do tego zadania, sprawdź kod źródłowy apache. Nie oznacza to jednak, że ludzie nie powinni używać dobrze przetestowanych rozwiązań.
Jurij Czernyszow
@YuriyChernyshov na pewno, miałem na myśli, że w większości nie powinni oni wymyślać kodu dla kodu produkcyjnego
Alvaro
WordUtils.capitalizeFully () działał dla mnie jak urok, ponieważ daje: WordUtils.capitalizeFully ("i am FINE") = "I Am Fine"
Atul Sharma
Nigdy nie pójdę do bibliotek zewnętrznych tylko do takiego celu How to capitalize the first letter of a String in Java?.
Przepełnienie stosu
25

Jawa:

po prostu metoda pomocnicza do wielkich liter każdego łańcucha.

public static String capitalize(String str)
{
    if(str == null) return str;
    return str.substring(0, 1).toUpperCase() + str.substring(1);
}

Potem po prostu zadzwoń str = capitalize(str)


Kotlin:

str.capitalize()
Amir Hossein Ghasemi
źródło
Zgłasza wyjątek, jeśli strwartość jest zerowa. Przed użyciem tego ciągu sprawdź, czy łańcuch nie ma wartości zerowej i ma co najmniej jeden znak.
attacomsian
@attacomsian masz rację, aktualizuję kod Java, a dla Kotlina możesz użyć str? .capitalize ()
Amir Hossein Ghasemi
22

Prawdopodobnie chcesz to:

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

(konwertuje pierwszy znak na wielkie litery i dodaje resztę oryginalnego ciągu)

Tworzysz także czytnik strumienia wejściowego, ale nigdy nie odczytujesz żadnej linii. Tak namezawsze będzienull .

To powinno działać:

BufferedReader br = new InputstreamReader(System.in);
String name = br.readLine();
String s1 = name.substring(0, 1).toUpperCase() + name.substring(1);
Grodriguez
źródło
12

Poniższe rozwiązanie będzie działać.

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

Nie można użyć metody ToUpperCase () na prymitywnym znaku, ale można najpierw utworzyć cały ciąg na wielkie litery, a następnie wziąć pierwszy znak, a następnie dołączyć do podłańcucha, jak pokazano powyżej.

Jijil Kakkadathu
źródło
toUpperCase jest ograniczony.
Harpreet Sandhu - TheRootCoder
W pytaniu starał się ulepszyć program prymitywny, który nie zadziała.
Jijil Kakkadathu
1
O. Tęskniłem za tym. (y)
Harpreet Sandhu - TheRootCoder
1
świetna odpowiedź kochanie
Dulaj Kulathunga
7

Najkrótszy też:

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

Pracował dla mnie.

Dassi Orleando
źródło
6

Ustaw ciąg na małe litery, a następnie ustaw pierwszą literę na górną w następujący sposób:

    userName = userName.toLowerCase();

następnie wielką literą pierwsza litera:

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

substring po prostu dostaje kawałek większego sznurka, a następnie łączymy je z powrotem.

AlexZeCoder
źródło
7
Sposób, w jaki go otrzymuję, pierwszy wiersz kodu jest bezużyteczny, ponieważ reszta ciągu ma małe litery.
Håvard Nygård
6

Co z 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);
    }
}
Arpit Aggarwal
źródło
6

Użyj tej metody użyteczności, aby uzyskać całą pierwszą literę wielkimi literami.

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);
}
Krrish
źródło
5
String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);
Aditya Parmar
źródło
4

Możesz także spróbować tego:

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

Jest to lepsze (zoptymalizowane) niż przy użyciu podciągów. (ale nie martw się o mały sznurek)

jerjer
źródło
4

Możesz użyć substring()do tego.

Ale są dwa różne przypadki:

Przypadek 1

Jeśli Stringkapitalizacja ma być czytelna dla człowieka, należy również określić domyślne ustawienia regionalne:

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

Przypadek 2

Jeśli wielkie Stringlitery mają być odczytywane maszynowo, unikaj ich używania, Locale.getDefault()ponieważ zwracany ciąg będzie niespójny w różnych regionach, aw tym przypadku zawsze określ te same ustawienia regionalne (na przykład toUpperCase(Locale.ENGLISH)). Zapewni to spójność ciągów używanych do przetwarzania wewnętrznego, co pomoże uniknąć trudnych do znalezienia błędów.

Uwaga: Nie trzeba określać Locale.getDefault()dla toLowerCase(), jak odbywa się to automatycznie.

JDJ
źródło
4

W Android Studio

Dodaj tę zależność do swojej build.gradle (Module: app)

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

Teraz możesz użyć

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

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

someTextView.setText(WordUtils.capitalize(string));
Michał
źródło
4

jeśli używasz WIOSNY :

import static org.springframework.util.StringUtils.capitalize;
...


    return capitalize(name);

UWAGA: Jeśli masz już zależność Apache Common Lang, rozważ użycie ich StringUtils.capitalize, jak sugerują inne odpowiedzi.

WDRAŻANIE: https://github.com/spring-projects/spring-framework/blob/64440a5f04a17b3728234afaa89f57766768decb/spring-core/src/main/java/org/springframework/util/StringUtils.java#5535-L

REF: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/StringUtils.html#capitalize-java.lang.String-

epoksydowy
źródło
4

TO DZIAŁA 101%

public class UpperCase {

    public static void main(String [] args) {

        String name;

        System.out.print("INPUT: ");
        Scanner scan = new Scanner(System.in);
        name  = scan.next();

        String upperCase = name.substring(0, 1).toUpperCase() + name.substring(1);
        System.out.println("OUTPUT: " + upperCase); 

    }

}
u_mewara
źródło
3

To tylko po to, aby pokazać, że się nie myliłeś.

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

Uwaga: To nie jest najlepszy sposób, aby to zrobić. Ma to na celu pokazanie PO, że można to również zrobić przy użyciu charAt(). ;)

Adeel Ansari
źródło
1
+1 za „nie tak źle”. Chciałbym wolą Character.toString(name.charAt(0)) zamiast ""+name.charAt(0)za pokazanie tego, co naprawdę chcesz robić.
user85421,
Brak kontroli zerowej długości. Długość może wynosić zero.
Chrispix,
3

To zadziała

char[] array = value.toCharArray();

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

String result = new String(array);
Mohamed Abdullah J.
źródło
3

Możesz użyć następującego kodu:

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

}
Mulalo Madida
źródło
3

Spróbuj tego

Metoda ta polega na tym, że słowo „witaj świecie” zamienia je w „Witaj świecie”, rozpoczynając wielkie słowo na początku każdego słowa.

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

    }
Ameen Maheen
źródło
Ale ten kod wydaje się dość zrozumiały, wszystkie metody są również łatwe do zrozumienia po ich nazwach. Ale dzięki za komentarz, postaram się uczynić doskonalszym od następnego razu, jestem zbyt leniwy :-).
Ameen Maheen,
Działa jak marzenie!
TheVinceble,
3

Podane odpowiedzi dotyczą dużej litery tylko jednego słowa. użyj następującego kodu, aby zapisać cały ciąg.

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

wynik : This Is A Random String

Vimukthi_R
źródło
3

Jeśli Input to UpperCase, użyj następujących poleceń:

str.substring (0, 1) .toUpperCase () + str.substring (1) .toLowerCase ();

Jeśli wartość wejściowa to LowerCase, użyj następujących opcji:

str. podciąg (0, 1) .toUpperCase () + str. podciąg (1);

Raj Kumar
źródło
2
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();
}
Doktor Brown
źródło
2

Możesz użyć następującego kodu:

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

}

przykładowy test z 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"));
}
David Navarro Astudillo
źródło
2

Użycie commons.lang.StringUtilsnajlepszej odpowiedzi to:

public static String capitalize(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;  
}

Uważam, że jest genialny, ponieważ owija ciąg za pomocą bufora StringBuffer. Możesz manipulować StringBuffer, jak chcesz i używając tej samej instancji.

prędkość
źródło
2

Jeszcze inny przykład, w jaki sposób pierwszą literę wprowadzanych przez użytkownika liter należy wpisać wielką literą:

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

źródło