Sto usando Java per ottenere un Stringinput dall'utente. Sto cercando di rendere maiuscola la prima lettera di questo input.

Ho provato questo:

String name;

BufferedReader br = new InputStreamReader(System.in);

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

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

che ha portato a questi errori del compilatore:

• Tipo non corrispondente: impossibile convertire da InputStreamReader a BufferedReader

• Impossibile richiamare toUppercase () sul carattere di tipo primitivo

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

Con il tuo esempio:

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

Il codice versione più breve / più veloce per scrivere in maiuscolo la prima lettera di una stringa è:

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

il valore di nameè"Stackoverflow"

Usa la libreria comune di Apache. Libera il tuo cervello da queste cose ed evita il Null Pointer & Index Out Of Bound Eccetions

Passo 1:

Importa la libreria di lingue comuni di apache inserendola nelle build.gradledipendenze

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

Passo 2:

Se sei sicuro che la tua stringa sia tutta in minuscolo, o tutto ciò che ti serve è inizializzare la prima lettera, chiama direttamente

StringUtils.capitalize(yourString);

Se vuoi assicurarti che solo la prima lettera sia maiuscola, come farlo per una enum, chiama toLowerCase()prima e tieni presente che verrà lanciata NullPointerExceptionse la stringa di input è nulla.

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

Ecco altri esempi forniti da Apache. è privo di eccezioni

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

Nota:

WordUtilsè anche incluso in questa libreria, ma è obsoleto. Per favore , non usarlo.

Giava:

semplicemente un metodo di supporto per capitalizzare ogni stringa.

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

Dopodiché chiama semplicemente str = capitalize(str)

Kotlin:

str.capitalize()

Quello che vuoi fare è probabilmente questo:

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

(converte il primo carattere in maiuscolo e aggiunge il resto della stringa originale)

Inoltre, si crea un lettore di flussi di input, ma non si legge mai alcuna riga. Così namesarà sempre null.

Questo dovrebbe funzionare:

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

Di seguito la soluzione funzionerà.

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

Non è possibile utilizzare toUpperCase () sul carattere primitivo, ma è possibile rendere prima l'intera stringa in maiuscolo, quindi prendere il primo carattere, quindi aggiungere alla sottostringa come mostrato sopra.

Usa WordUtils.capitalize(str).

Anche il più corto:

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

Ha funzionato per me.

Imposta la stringa in minuscolo, quindi imposta la prima lettera in maiuscolo in questo modo:

    userName = userName.toLowerCase();

quindi per scrivere in maiuscolo la prima lettera:

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

la sottostringa sta semplicemente ottenendo un pezzo di una stringa più grande, quindi le stiamo combinando di nuovo insieme.

Che dire di 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);
    }
}

Utilizzare questo metodo di utilità per ottenere tutta la prima lettera maiuscola.

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

Puoi anche provare questo:

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

Questo è meglio (ottimizzato) rispetto all'utilizzo della sottostringa. (ma non preoccuparti di stringhe piccole)

Puoi usare substring()per fare questo.

Ma ci sono due casi diversi:

Caso 1

Se le Stringlettere maiuscole devono essere leggibili dall'uomo, è necessario specificare anche le impostazioni internazionali predefinite:

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

Caso 2

Se le lettere Stringmaiuscole devono essere leggibili automaticamente, evita di usarle Locale.getDefault()perché la stringa restituita sarà incoerente tra regioni diverse e in questo caso specifica sempre la stessa locale (ad esempio toUpperCase(Locale.ENGLISH)). Ciò assicurerà che le stringhe utilizzate per l'elaborazione interna siano coerenti, il che consentirà di evitare bug difficili da trovare.

Nota: non è necessario specificare Locale.getDefault()per toLowerCase(), poiché ciò avviene automaticamente.

In Android Studio

Aggiungi questa dipendenza al tuo build.gradle (Module: app)

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

Ora puoi usare

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

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

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

se usi PRIMAVERA :

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


    return capitalize(name);

NOTA: se hai già la dipendenza da Apache Common Lang, allora considera di usare StringUtils.capitalize come suggeriscono altre risposte.

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

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

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

    }

}

Questo è solo per mostrarti che non eri così sbagliato.

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

Nota: questo non è affatto il modo migliore per farlo. Questo serve solo a mostrare all'OP che può essere fatto anche usando charAt(). ;)

Questo funzionerà

char[] array = value.toCharArray();

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

String result = new String(array);

Puoi usare il seguente codice:

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

}

prova questo

Quello che fa questo metodo è che, considera la parola "ciao mondo" questo metodo lo trasforma in "Ciao mondo" maiuscole all'inizio di ogni parola.

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

    }

Le risposte fornite servono a scrivere in maiuscolo la prima lettera di una sola parola. utilizzare il seguente codice per scrivere in maiuscolo un'intera stringa.

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

produzione : This Is A Random String

Se Input è UpperCase, utilizzare quindi quanto segue:

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

Se Input è LowerCase, utilizzare quindi quanto segue:

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

Dai un'occhiata a ACL WordUtils.

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

Come maiuscole ogni prima lettera di una stringa?

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

Puoi usare il seguente codice:

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

}

esempio di test con 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"));
}

Utilizzando commons.lang.StringUtilsla migliore risposta è:

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

Lo trovo geniale poiché avvolge la stringa con uno StringBuffer. Puoi manipolare StringBuffer come desideri e usando la stessa istanza.

Ancora un altro esempio, come è possibile rendere maiuscola la prima lettera dell'input dell'utente:

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