Come scrivere in maiuscolo la prima lettera in una stringa usando Java?

Stringhe di esempio

one thousand only
two hundred
twenty
seven

Come posso cambiare il primo carattere di una stringa in maiuscolo e non cambiare il caso di nessuna delle altre lettere?

Dopo la modifica dovrebbe essere:

One thousand only
Two hundred
Twenty
Seven

Nota: non voglio usare apache.commons.lang.WordUtils per fare questo.

Se vuoi solo scrivere in maiuscolo la prima lettera di una stringa denominata inpute lasciare il resto da solo:

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

Ora outputavrà quello che vuoi. Verifica che il tuo inputsia almeno un personaggio molto prima di usarlo, altrimenti otterrai un'eccezione.

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

Solo ... una soluzione completa, vedo che è finito per combinare ciò che tutti gli altri hanno finito per pubblicare = P.

Il modo più semplice è usare la org.apache.commons.lang.StringUtilsclasse

StringUtils.capitalize(Str);

Inoltre, c'è org.springframework.util.StringUtilsin Spring Framework :

StringUtils.capitalize(str);

StringUtils.capitalize(str)

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

Ecco qua (spero che questo ti dia l'idea):

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

}

Per questo è necessario un solo codice di riga. se String A = scanner.nextLine(); è necessario scrivere questo per visualizzare la stringa con questa prima lettera maiuscola.

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

Ed è fatto ora.

Esempio usando la classe 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);
} 

Soluzione con StringBuilder:

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

.. in base alle risposte precedenti

Aggiungendo tutto insieme, è una buona idea tagliare lo spazio bianco extra all'inizio della corda. Altrimenti, .substring (0,1) .toUpperCase proverà a capitalizzare uno spazio bianco.

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

Il mio approccio funzionale. il suo primo personaggio viene catturato in frase dopo essere stato scavalcato in un intero paragrafo.

Per capatilizzare solo il primo carattere della parola basta rimuovere .split ("")

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

Aggiornamento luglio 2019

Attualmente è contenuta la funzione di libreria più aggiornata per farlo org.apache.commons.lang3.StringUtils

import org.apache.commons.lang3.StringUtils;

StringUtils.capitalize(myString);

Se stai usando Maven, importa la dipendenza nel tuo pom.xml:

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

Anche per il codice "semplice", userei le librerie. La cosa non è il codice in sé, ma i casi di test già esistenti che coprono casi eccezionali. Questo potrebbe essere null, stringhe vuote, stringhe in altre lingue.

La parte di manipolazione delle parole è stata spostata da Apache Commons Lang. Ora è inserito nel testo di Apache Commons . Scaricalo via https://search.maven.org/artifact/org.apache.commons/commons-text .

Puoi usare WordUtils.capitalize (String str) da Apache Commons Text. È più potente di quello che hai chiesto. Può anche capitalizzare completamente (es. Correzione "oNe tousand only").

Dal momento che funziona sul testo completo, bisogna dirgli di scrivere in maiuscolo solo la prima parola.

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

Classe JUnit completa per consentire di giocare con la funzionalità:

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

}

se si desidera solo scrivere in maiuscolo la prima lettera, è possibile utilizzare il codice seguente

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

In realtà, otterrai le migliori prestazioni se eviti l' +operatore e utilizzalo concat()in questo caso. È l'opzione migliore per unire solo 2 stringhe (non così buona per molte stringhe). In tal caso il codice sarebbe simile al seguente:

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

Usa questo:

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

Data la inputstringa:

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

Puoi provare il seguente codice:

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

Vorrei aggiungere un controllo NULL e IndexOutOfBoundsException sulla risposta accettata.

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

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

Produzione:

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]

Quanto segue ti darà lo stesso output coerente indipendentemente dal valore del tuo inputString:

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

1. Utilizzo del substring()metodo String

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

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

Ora chiama il capitalize()metodo per convertire la prima lettera di una stringa in maiuscolo:

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

2. Apache Commons Lang

La StringUtilsclasse di Commons Lang fornisce il capitalize()metodo che può essere utilizzato anche per questo scopo:

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

Aggiungi la seguente dipendenza al tuo pom.xmlfile (solo per Maven):

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

Ecco un articolo che spiega in dettaglio questi due approcci.

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