Saya menggunakan Java untuk mendapatkan Stringinput dari pengguna. Saya mencoba membuat huruf pertama dari input ini menjadi huruf besar.

Saya mencoba ini:

String name;

BufferedReader br = new InputStreamReader(System.in);

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

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

yang menyebabkan kesalahan kompilator ini:

• Ketik ketidakcocokan: tidak bisa mengonversi dari InputStreamReader ke BufferedReader

• Tidak dapat meminta toUppercase () pada char tipe primitif

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

Dengan contoh Anda:

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(..) dari commons-lang

Kode versi yang lebih pendek / lebih cepat untuk menggunakan huruf kapital huruf pertama dari String adalah:

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

nilai nameis"Stackoverflow"

Gunakan perpustakaan umum Apache. Bebaskan otak Anda dari barang-barang ini dan hindari Null Pointer & Index Out Of Bound Exception

Langkah 1:

Impor perpustakaan umum apache dengan meletakkan ini di build.gradledependensi

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

Langkah 2:

Jika Anda yakin string Anda menggunakan huruf kecil, atau yang Anda butuhkan adalah menginisialisasi huruf pertama, langsung hubungi

StringUtils.capitalize(yourString);

Jika Anda ingin memastikan bahwa hanya huruf pertama yang ditulis dengan huruf besar, seperti melakukan ini untuk enum, panggil toLowerCase()dulu dan ingatlah bahwa itu akan dilemparkan NullPointerExceptionjika string inputnya nol.

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

Berikut adalah lebih banyak sampel yang disediakan oleh apache. itu pengecualian gratis

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

catatan:

WordUtilsjuga termasuk dalam perpustakaan ini, tetapi sudah usang. Tolong jangan gunakan itu.

Jawa:

hanya metode pembantu untuk memanfaatkan setiap string.

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

Setelah itu cukup panggil str = capitalize(str)

Kotlin:

str.capitalize()

Apa yang ingin Anda lakukan mungkin ini:

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

(mengkonversi karakter pertama ke huruf besar dan menambahkan sisa dari string asli)

Juga, Anda membuat pembaca aliran input, tetapi tidak pernah membaca baris apa pun. Jadi nameakan selalu begitu null.

Ini seharusnya bekerja:

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)dari Apache Commons .

Solusi di bawah ini akan berfungsi.

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

Anda tidak dapat menggunakan toUpperCase () pada char primitive, tetapi Anda dapat membuat seluruh String menjadi Huruf besar terlebih dahulu kemudian mengambil char pertama, kemudian menambahkan substring seperti yang ditunjukkan di atas.

Gunakan WordUtils.capitalize(str).

Terpendek juga:

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

Bekerja untukku.

Atur string ke huruf kecil, lalu atur Huruf pertama ke atas seperti ini:

    userName = userName.toLowerCase();

lalu dengan huruf besar huruf pertama:

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

Substring hanya mendapatkan seutas tali yang lebih besar, lalu kita gabungkan kembali.

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

Gunakan metode utilitas ini untuk mendapatkan semua huruf pertama di ibukota.

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

Anda juga dapat mencoba ini:

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

Ini lebih baik (dioptimalkan) daripada dengan menggunakan substring. (tapi jangan khawatir dengan string kecil)

Anda dapat menggunakannya substring()untuk melakukan ini.

Tetapi ada dua kasus berbeda:

Kasus 1

Jika Stringhuruf kapital yang Anda gunakan dimaksudkan agar dapat dibaca oleh manusia, Anda juga harus menentukan lokal default:

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

Kasus 2

Jika Stringkapitalisasi yang Anda maksud dapat dibaca oleh mesin, hindari menggunakan Locale.getDefault()karena string yang dikembalikan akan tidak konsisten di berbagai wilayah, dan dalam hal ini selalu tentukan lokal yang sama (misalnya,toUpperCase(Locale.ENGLISH) ). Ini akan memastikan bahwa string yang Anda gunakan untuk pemrosesan internal konsisten, yang akan membantu Anda menghindari bug yang sulit ditemukan.

Catatan: Anda tidak harus menentukan Locale.getDefault()untuk toLowerCase(), karena ini dilakukan secara otomatis.

Di Android Studio

Tambahkan ketergantungan ini ke build.gradle (Module: app)

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

Sekarang kamu bisa menggunakannya

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

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

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

jika Anda menggunakan SPRING :

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


    return capitalize(name);

CATATAN: Jika Anda sudah memiliki ketergantungan Apache Common Lang, maka pertimbangkan untuk menggunakan StringUtils.capitalize mereka sebagai jawaban lain menyarankan.

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

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

ITU AKAN BEKERJA 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); 

    }

}

Ini hanya untuk menunjukkan kepada Anda, bahwa Anda tidak salah.

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

Catatan: Ini sama sekali bukan cara terbaik untuk melakukannya. Ini hanya untuk menunjukkan kepada OP bahwa itu dapat dilakukan dengan menggunakan charAt()juga. ;)

Ini akan bekerja

char[] array = value.toCharArray();

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

String result = new String(array);

Anda dapat menggunakan kode berikut:

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

}

coba yang ini

Apa yang dilakukan metode ini adalah, Pertimbangkan kata "hello world", metode ini mengubahnya menjadi "Hello World" dengan huruf kapital di awal setiap kata.

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

    }

Jawaban yang diberikan adalah untuk huruf besar huruf pertama dari satu kata saja. gunakan kode berikut untuk menggunakan seluruh string.

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

keluaran: This Is A Random String

Jika Masukan adalah Huruf Besar, maka Gunakan berikut ini:

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

Jika Inputnya lebih rendah, maka gunakan yang berikut:

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

Lihatlah ACL WordUtils.

WordUtils.capitalize ("your string") == "Your String"

Bagaimana huruf besar setiap huruf pertama dalam sebuah string?

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

Anda dapat menggunakan kode berikut:

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

}

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

Menggunakan commons.lang.StringUtilsjawaban terbaik adalah:

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

Saya merasa brilian karena membungkus string dengan StringBuffer. Anda dapat memanipulasi StringBuffer seperti yang Anda inginkan dan meskipun menggunakan instance yang sama.

Contoh lain, bagaimana Anda bisa membuat huruf pertama dari input pengguna menjadi kapital:

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