Ich benutze Java, um eine StringEingabe vom Benutzer zu erhalten. Ich versuche, den ersten Buchstaben dieser Eingabe groß zu schreiben.

Ich habe es 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 Compilerfehlern führte:

• Typkonflikt: Konvertiert nicht von InputStreamReader in BufferedReader

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

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

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

StringUtils.capitalize(..) von commons-lang

Der kürzere / schnellere Versionscode zum Großschreiben des ersten Buchstabens eines Strings lautet:

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

der Wert von nameist"Stackoverflow"

Verwenden Sie die allgemeine Bibliothek von Apache. Befreien Sie Ihr Gehirn von diesen Dingen und vermeiden Sie Null Pointer & Index Out of Bound Exceptions

Schritt 1:

Importieren Sie die allgemeine Lang-Bibliothek von Apache, indem Sie diese in build.gradleAbhängigkeiten einfügen

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

Schritt 2:

Wenn Sie sicher sind, dass Ihre Zeichenfolge nur in Kleinbuchstaben geschrieben ist oder Sie nur den ersten Buchstaben initialisieren müssen, rufen Sie direkt an

StringUtils.capitalize(yourString);

Wenn Sie sicherstellen möchten, dass nur der erste Buchstabe groß geschrieben wird, wie dies für a der Fall ist enum, rufen Sie toLowerCase()zuerst auf und denken Sie daran, dass er ausgelöst wird, NullPointerExceptionwenn die Eingabezeichenfolge null ist.

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

Hier finden Sie weitere Beispiele von Apache. Es ist ausnahmefrei

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

Hinweis:

WordUtilsist ebenfalls in dieser Bibliothek enthalten, aber veraltet. Bitte benutzen Sie das nicht .

Java:

einfach eine Hilfsmethode zum Großschreiben jeder Zeichenfolge.

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

Danach einfach anrufen str = capitalize(str)

Kotlin:

str.capitalize()

Was Sie tun möchten, ist wahrscheinlich Folgendes:

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

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

Außerdem erstellen Sie einen Eingabestream-Reader, lesen jedoch niemals eine Zeile. So namewird es immer seinnull .

Das sollte funktionieren:

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

WordUtils.capitalize(java.lang.String)von Apache Commons .

Die folgende Lösung wird funktionieren.

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

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

Verwenden Sie WordUtils.capitalize(str).

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

Hat für mich gearbeitet.

Setzen Sie die Zeichenfolge auf Kleinbuchstaben und dann den ersten Buchstaben wie folgt auf Großbuchstaben:

    userName = userName.toLowerCase();

dann, um den ersten Buchstaben groß zu schreiben:

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

Teilzeichenfolge bekommt nur ein Stück einer größeren Zeichenfolge, dann kombinieren wir sie wieder zusammen.

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

Verwenden Sie diese Dienstprogrammmethode, um alle Anfangsbuchstaben in Großbuchstaben zu erhalten.

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

String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);

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 Verwendung von Teilzeichenfolgen. (aber keine Sorge um kleine Schnur)

Sie können substring()dies verwenden.

Es gibt jedoch zwei verschiedene Fälle:

Fall 1

Wenn das, was StringSie 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 StringGroßschreibung maschinenlesbar sein soll, vermeiden Sie die Verwendung, Locale.getDefault()da die zurückgegebene Zeichenfolge in verschiedenen Regionen inkonsistent ist. Geben Sie in diesem Fall immer dasselbe Gebietsschema an (z. B.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 nicht angeben müssen Locale.getDefault()für toLowerCase(), da dies automatisch geschieht.

In Android Studio

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

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

Wenn Sie SPRING verwenden :

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


    return capitalize(name);

HINWEIS: Wenn Sie bereits eine Apache Common Lang-Abhängigkeit haben, sollten Sie die Verwendung von StringUtils.capitalize in Betracht ziehen, wie andere Antworten vorschlagen.

UMSETZUNG: https://github.com/spring-projects/spring-framework/blob/64440a5f04a17b3728234afaa89f57766768decb/spring-core/src/main/java/org/springframework/util/StringUtils.java5

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

ES WIRD 101% ARBEITEN

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

    }

}

Dies soll Ihnen nur zeigen, dass Sie nicht so falsch lagen.

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 verwendet werden kann charAt(). ;)

Das wird funktionieren

char[] array = value.toCharArray();

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

String result = new String(array);

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

}

Probier diese

Diese Methode bewirkt Folgendes: Betrachten Sie das Wort "Hallo Welt". Verwandeln Sie diese Methode in "Hallo Welt" und schreiben Sie den Anfang jedes Wortes groß.

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

    }

Bei gegebenen Antworten wird nur der erste Buchstabe eines Wortes groß geschrieben. Verwenden Sie den folgenden Code, um eine ganze Zeichenfolge groß 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

Wenn Input UpperCase ist, verwenden Sie Folgendes:

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

Wenn Input LowerCase ist, verwenden Sie Folgendes:

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

Schauen Sie sich ACL WordUtils an.

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

Wie wird jeder erste Buchstabe eines Wortes in einer Zeichenfolge in Großbuchstaben geschrieben?

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

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

Mit commons.lang.StringUtilsder besten Antwort ist:

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

Ich finde es brillant, da es den String mit einem StringBuffer umschließt. Sie können den StringBuffer beliebig bearbeiten und dabei dieselbe Instanz verwenden.

Ein weiteres Beispiel, wie Sie den ersten Buchstaben der Benutzereingabe groß schreiben 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)));