Jak wpisać pierwszy znak każdego słowa w ciągu


421

Czy w Javie jest wbudowana funkcja, która zapisuje pierwszy znak każdego słowa w ciągu i nie wpływa na pozostałe?

Przykłady:

  • jon skeet -> Jon Skeet
  • miles o'Brien-> Miles O'Brien(B pozostaje kapitałem, wyklucza to tytuł Case)
  • old mcdonald-> Old Mcdonald*

* (też Old McDonaldby się to znalazło, ale nie oczekuję, że będzie TAKIE mądre.)

Szybkie spojrzenie na dokumentację napisów Java ujawnia tylko toUpperCase()i toLowerCase(), które oczywiście nie zapewniają pożądanego zachowania. Oczywiście wyniki Google są zdominowane przez te dwie funkcje. Wygląda to na koło, które musiało zostać już wynalezione, więc nie zaszkodzi zapytać, abym mógł z niego korzystać w przyszłości.


18
Co old mcdonald? Czy to powinno się stać Old McDonald?
Bart Kiers,

2
Nie oczekuję, że funkcja będzie tak inteligentna. (Chociaż jeśli masz taki, chętnie go zobaczę.) Po prostu pierwsza litera po białej spacji, ale zignoruj ​​resztę.
WillfulWizard,


1
W każdym razie nie można znaleźć algorytmu, który właściwie obsługuje wielkie litery po fakcie ... dopóki istnieją pary nazw, które mogą być poprawne dla danej osoby, takie jak MacDonald i Macdonald, funkcja nie mogę wiedzieć, co było poprawne. Lepiej jest robić to, co zrobiłeś, chociaż niektóre nazwy będą błędne (np. Von Neumann).
Dave DuPlantis,

Spróbuj Burger King ...
Magno C

Odpowiedzi:


732

WordUtils.capitalize(str)(z apache commons-text )

(Uwaga: jeśli musisz "fOO BAr"zostać "Foo Bar", użyj capitalizeFully(..)zamiast tego)


5
Myślę, że masz na myśli WordUtils.capitalize (str). Aby uzyskać szczegółowe informacje, zobacz API
Hans Doggen,

84
Utrzymanie mojej filozofii ciągłego głosowania na odpowiedzi dotyczące bibliotek wspólnych.
Ravi Wallau,

11
Aby zmienić nie pierwszą literę na słowa pisane małymi literami, użyj capitalizeFully (str).
Umesh Rajbhandari

5
Czy to rozwiązanie jest naprawdę poprawne ? to nie jest moim zdaniem! Jeśli chcesz wykorzystać „LAMborghini”, na końcu chcesz „Lamborghini”. Takie WordUtils.capitalizeFully(str)jest rozwiązanie.
basZero

3
@BasZero to właściwa odpowiedź na zadane pytanie. Uwzględnię wersję w pełni jako komentarz.
Bozho

229

Jeśli martwisz się tylko, że pierwsza litera pierwszego słowa jest pisana wielką literą:

private String capitalize(final String line) {
   return Character.toUpperCase(line.charAt(0)) + line.substring(1);
}

3
zmienia to tylko pierwszą literę pierwszego słowa
Chrizzz

28
Rzeczywiście, taki był mój zamiar.
Nick Bolton,

13
@nbolton - ale wyraźnie ignoruje cel pytania i nie udaje się w przypadkach podanych w tym przykładzie - i dodaje niewiele lub nic do wcześniej udzielonych odpowiedzi!
David Manheim

17
Ten fragment kodu nie jest odporny na awarie! Wyobraź sobie, lineże jesteś zerowy lub masz długość <2.
stk

1
nadal zwracaj Character.toUpperCase (word.charAt (0)) + word.substring (1) .toLowerCase ()
Excepttyon

72

Poniższa metoda konwertuje wszystkie litery na wielkie / małe litery, w zależności od ich położenia w pobliżu spacji lub innych znaków specjalnych.

public static String capitalizeString(String string) {
  char[] chars = string.toLowerCase().toCharArray();
  boolean found = false;
  for (int i = 0; i < chars.length; i++) {
    if (!found && Character.isLetter(chars[i])) {
      chars[i] = Character.toUpperCase(chars[i]);
      found = true;
    } else if (Character.isWhitespace(chars[i]) || chars[i]=='.' || chars[i]=='\'') { // You can add other chars here
      found = false;
    }
  }
  return String.valueOf(chars);
}

Chciałbym poprawić i uprościć warunki pętli: if(Character.isLetter(chars[i])) { if(!found) { chars[i] = Character.toUpperCase(chars[i]); } found = true; } else { found = false; }.
bancer

@bancer, w twoim przykładzie nie możesz kontrolować, które znaki nie będą poprzedzone wielką literą.
True Soft,

@TrueSoft, nie rozumiem cię. Dlaczego musisz kontrolować, jakie znaki będą występować po wielkich literach? Jak zrozumiałem, ważne jest, aby poprzedni znak nie był literą, a mój przykład to zapewnia. Po prostu zamień blok if-else-if na blok if-else i uruchom test.
bancer

@TrueSoft, dla jasności zmieniłbym nazwę foundna previousCharIsLetter.
bancer

9
Lubię mieć odpowiedzi, które nie korzystają z biblioteki commons, ponieważ co jakiś czas nie możesz jej użyć.
Heckman

38

Wypróbuj ten bardzo prosty sposób

przykład podanyString = "ram jest dobrym chłopcem"

public static String toTitleCase(String givenString) {
    String[] arr = givenString.split(" ");
    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < arr.length; i++) {
        sb.append(Character.toUpperCase(arr[i].charAt(0)))
            .append(arr[i].substring(1)).append(" ");
    }          
    return sb.toString().trim();
}  

Wyjście będzie: Ram Is Good Boy


1
ten kod spowodował awarię naszego serwera: java.lang.StringIndexOutOfBoundsException: Indeks łańcucha poza zakresem: 0
Chrizzz

32
@Chrizzz, więc nie zatwierdzaj kodu, którego nie testowałeś ... Jeśli podasz pusty ciąg znaków, nastąpi awaria. Twoja wina, nie Neelam.
Reinherd

1
Jeśli istnieje przestrzeń na końcu to jest upaść potem dodałem trim () pierwsza i podzielić ciąg z space.It działało idealnie
Hanuman

Jeśli ktoś szuka jego wersji Kotlin, oto: stackoverflow.com/a/55390188/1708390
Bugs Happen

16

Napisałem małą klasę, aby wielkie litery wszystkich słów składały się z wielkich liter.

Opcjonalnie multiple delimiters, każdy z zachowaniem (wielkie litery przed, po lub oba, aby obsłużyć przypadki takie jak O'Brian);

Opcjonalne Locale;

Nie zrywaj z Surrogate Pairs.

DEMO NA ŻYWO

Wynik:

====================================
 SIMPLE USAGE
====================================
Source: cApItAlIzE this string after WHITE SPACES
Output: Capitalize This String After White Spaces

====================================
 SINGLE CUSTOM-DELIMITER USAGE
====================================
Source: capitalize this string ONLY before'and''after'''APEX
Output: Capitalize this string only beforE'AnD''AfteR'''Apex

====================================
 MULTIPLE CUSTOM-DELIMITER USAGE
====================================
Source: capitalize this string AFTER SPACES, BEFORE'APEX, and #AFTER AND BEFORE# NUMBER SIGN (#)
Output: Capitalize This String After Spaces, BeforE'apex, And #After And BeforE# Number Sign (#)

====================================
 SIMPLE USAGE WITH CUSTOM LOCALE
====================================
Source: Uniforming the first and last vowels (different kind of 'i's) of the Turkish word D[İ]YARBAK[I]R (DİYARBAKIR) 
Output: Uniforming The First And Last Vowels (different Kind Of 'i's) Of The Turkish Word D[i]yarbak[i]r (diyarbakir) 

====================================
 SIMPLE USAGE WITH A SURROGATE PAIR 
====================================
Source: ab 𐐂c de à
Output: Ab 𐐪c De À

Uwaga: pierwsza litera zawsze będzie pisana wielkimi literami (jeśli nie chcesz, edytuj źródło).

Podziel się swoimi komentarzami i pomóż mi znaleźć błędy lub poprawić kod ...

Kod:

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;

public class WordsCapitalizer {

    public static String capitalizeEveryWord(String source) {
        return capitalizeEveryWord(source,null,null);
    }

    public static String capitalizeEveryWord(String source, Locale locale) {
        return capitalizeEveryWord(source,null,locale);
    }

    public static String capitalizeEveryWord(String source, List<Delimiter> delimiters, Locale locale) {
        char[] chars; 

        if (delimiters == null || delimiters.size() == 0)
            delimiters = getDefaultDelimiters();                

        // If Locale specified, i18n toLowerCase is executed, to handle specific behaviors (eg. Turkish dotted and dotless 'i')
        if (locale!=null)
            chars = source.toLowerCase(locale).toCharArray();
        else 
            chars = source.toLowerCase().toCharArray();

        // First charachter ALWAYS capitalized, if it is a Letter.
        if (chars.length>0 && Character.isLetter(chars[0]) && !isSurrogate(chars[0])){
            chars[0] = Character.toUpperCase(chars[0]);
        }

        for (int i = 0; i < chars.length; i++) {
            if (!isSurrogate(chars[i]) && !Character.isLetter(chars[i])) {
                // Current char is not a Letter; gonna check if it is a delimitrer.
                for (Delimiter delimiter : delimiters){
                    if (delimiter.getDelimiter()==chars[i]){
                        // Delimiter found, applying rules...                       
                        if (delimiter.capitalizeBefore() && i>0 
                            && Character.isLetter(chars[i-1]) && !isSurrogate(chars[i-1]))
                        {   // previous character is a Letter and I have to capitalize it
                            chars[i-1] = Character.toUpperCase(chars[i-1]);
                        }
                        if (delimiter.capitalizeAfter() && i<chars.length-1 
                            && Character.isLetter(chars[i+1]) && !isSurrogate(chars[i+1]))
                        {   // next character is a Letter and I have to capitalize it
                            chars[i+1] = Character.toUpperCase(chars[i+1]);
                        }
                        break;
                    }
                } 
            }
        }
        return String.valueOf(chars);
    }


    private static boolean isSurrogate(char chr){
        // Check if the current character is part of an UTF-16 Surrogate Pair.  
        // Note: not validating the pair, just used to bypass (any found part of) it.
        return (Character.isHighSurrogate(chr) || Character.isLowSurrogate(chr));
    }       

    private static List<Delimiter> getDefaultDelimiters(){
        // If no delimiter specified, "Capitalize after space" rule is set by default. 
        List<Delimiter> delimiters = new ArrayList<Delimiter>();
        delimiters.add(new Delimiter(Behavior.CAPITALIZE_AFTER_MARKER, ' '));
        return delimiters;
    } 

    public static class Delimiter {
        private Behavior behavior;
        private char delimiter;

        public Delimiter(Behavior behavior, char delimiter) {
            super();
            this.behavior = behavior;
            this.delimiter = delimiter;
        }

        public boolean capitalizeBefore(){
            return (behavior.equals(Behavior.CAPITALIZE_BEFORE_MARKER)
                    || behavior.equals(Behavior.CAPITALIZE_BEFORE_AND_AFTER_MARKER));
        }

        public boolean capitalizeAfter(){
            return (behavior.equals(Behavior.CAPITALIZE_AFTER_MARKER)
                    || behavior.equals(Behavior.CAPITALIZE_BEFORE_AND_AFTER_MARKER));
        }

        public char getDelimiter() {
            return delimiter;
        }
    }

    public static enum Behavior {
        CAPITALIZE_AFTER_MARKER(0),
        CAPITALIZE_BEFORE_MARKER(1),
        CAPITALIZE_BEFORE_AND_AFTER_MARKER(2);                      

        private int value;          

        private Behavior(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }           
    } 

15
String toBeCapped = "i want this sentence capitalized";

String[] tokens = toBeCapped.split("\\s");
toBeCapped = "";

for(int i = 0; i < tokens.length; i++){
    char capLetter = Character.toUpperCase(tokens[i].charAt(0));
    toBeCapped +=  " " + capLetter + tokens[i].substring(1);
}
toBeCapped = toBeCapped.trim();

1
Hmmm, myślę, że druga linia w pętli for powinna brzmieć: toBeCapped + = "" + capLetter + tokeny [i] .substring (1, tokeny [i] .length ());
jengelsma

1
Ale to rozwiązanie doda spację na początku. Może być konieczne wykonanie lewego przycięcia.
Kamalakannan J

13

Zrobiłem rozwiązanie w Javie 8, które jest IMHO bardziej czytelne.

public String firstLetterCapitalWithSingleSpace(final String words) {
    return Stream.of(words.trim().split("\\s"))
    .filter(word -> word.length() > 0)
    .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1))
    .collect(Collectors.joining(" "));
}

Gist dla tego rozwiązania można znaleźć tutaj: https://gist.github.com/Hylke1982/166a792313c5e2df9d31


10

Używanie org.apache.commons.lang.StringUtilsczyni to bardzo prostym.

capitalizeStr = StringUtils.capitalize(str);

2
@ Ash StringUtils.capitalise(str)jest przestarzałe. Zobacz: commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/…
Navigatron

To tylko wielkie litery pierwszego łańcucha, a nie pierwszy znak każdego słowa w łańcuchu. WordUtils jest przestarzałe tylko dlatego, że przeniósł się ze wspólnego języka
opticyclic

Nie jest dobrym pomysłem korzystanie z zewnętrznej biblioteki do drobnych zadań.
Przepełnienie stosu

7

Za pomocą tego prostego kodu :

String example="hello";

example=example.substring(0,1).toUpperCase()+example.substring(1, example.length());

System.out.println(example);

Wynik: cześć


6
co z WITAJĄ zwraca CZEŚĆ, ale oczekuje Cześć, więc użyjesz funkcji toLowerCase () w drugim SubString
Trikaldarshi 21.09.2013

5

Korzystam z następującej funkcji. Myślę, że wydajność jest szybsza.

public static String capitalize(String text){
    String c = (text != null)? text.trim() : "";
    String[] words = c.split(" ");
    String result = "";
    for(String w : words){
        result += (w.length() > 1? w.substring(0, 1).toUpperCase(Locale.US) + w.substring(1, w.length()).toLowerCase(Locale.US) : w) + " ";
    }
    return result.trim();
}

3
Zawsze używaj StringBuilder podczas konkatenacji zamiast + =
chitgoks

2
Jak myślisz, dlaczego jest szybszy?
Peter Mortensen

5

Z Java 9+

możesz użyć w String::replaceAllten sposób:

public static void upperCaseAllFirstCharacter(String text) {
    String regex = "\\b(.)(.*?)\\b";
    String result = Pattern.compile(regex).matcher(text).replaceAll(
            matche -> matche.group(1).toUpperCase() + matche.group(2)
    );

    System.out.println(result);
}

Przykład:

upperCaseAllFirstCharacter("hello this is Just a test");

Wyjścia

Hello This Is Just A Test

4

Użyj metody podziału, aby podzielić ciąg na słowa, a następnie użyj wbudowanych funkcji ciągów, aby wstawić wielkie słowa do każdego słowa, a następnie dodaj je razem.

Pseudokod (ish)

string = "the sentence you want to apply caps to";
words = string.split(" ") 
string = ""
for(String w: words)

//This line is an easy way to capitalize a word
    word = word.toUpperCase().replace(word.substring(1), word.substring(1).toLowerCase())

    string += word

Na końcu napis wygląda jak „Zdanie, do którego chcesz zastosować czapki”


4

Może to być przydatne, jeśli potrzebujesz wielkich liter. Wielkie podciąg jest rozdzielany wielkimi literami " ", z wyjątkiem określonych ciągów, takich jak "a"lub "the". Nie uruchomiłem go jeszcze, ponieważ jest późno, choć powinno być w porządku. StringUtils.join()W pewnym momencie korzysta z Apache Commons . Jeśli chcesz, możesz zastąpić go prostą pętlą.

private static String capitalize(String string) {
    if (string == null) return null;
    String[] wordArray = string.split(" "); // Split string to analyze word by word.
    int i = 0;
lowercase:
    for (String word : wordArray) {
        if (word != wordArray[0]) { // First word always in capital
            String [] lowercaseWords = {"a", "an", "as", "and", "although", "at", "because", "but", "by", "for", "in", "nor", "of", "on", "or", "so", "the", "to", "up", "yet"};
            for (String word2 : lowercaseWords) {
                if (word.equals(word2)) {
                    wordArray[i] = word;
                    i++;
                    continue lowercase;
                }
            }
        }
        char[] characterArray = word.toCharArray();
        characterArray[0] = Character.toTitleCase(characterArray[0]);
        wordArray[i] = new String(characterArray);
        i++;
    }
    return StringUtils.join(wordArray, " "); // Re-join string
}

Łamie się, jeśli łańcuch zawiera podwójne spacje, co jest głupie dla danych wejściowych, ale FYI.
JustTrying

4
public static String toTitleCase(String word){
    return Character.toUpperCase(word.charAt(0)) + word.substring(1);
}

public static void main(String[] args){
    String phrase = "this is to be title cased";
    String[] splitPhrase = phrase.split(" ");
    String result = "";

    for(String word: splitPhrase){
        result += toTitleCase(word) + " ";
    }
    System.out.println(result.trim());
}

Witamy w Stack Overflow! Zasadniczo odpowiedzi są o wiele bardziej pomocne, jeśli zawierają wyjaśnienie, do czego służy kod i dlaczego rozwiązuje problem bez przedstawiania innych.
Neuron

Zdecydowanie
najprostsze

3
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));   

System.out.println("Enter the sentence : ");

try
{
    String str = br.readLine();
    char[] str1 = new char[str.length()];

    for(int i=0; i<str.length(); i++)
    {
        str1[i] = Character.toLowerCase(str.charAt(i));
    }

    str1[0] = Character.toUpperCase(str1[0]);
    for(int i=0;i<str.length();i++)
    {
        if(str1[i] == ' ')
        {                   
            str1[i+1] =  Character.toUpperCase(str1[i+1]);
        }
        System.out.print(str1[i]);
    }
}
catch(Exception e)
{
    System.err.println("Error: " + e.getMessage());
}

To najprostsza, podstawowa i najlepsza odpowiedź dla nowicjusza takiego jak ja!
abhishah901

3

Postanowiłem dodać jeszcze jedno rozwiązanie dla wielkich liter w ciągu:

  • wyrazy są tu definiowane jako sąsiednie litery lub cyfry;
  • zapewnione są również pary zastępcze;
  • kod został zoptymalizowany pod kątem wydajności; i
  • wciąż jest kompaktowy.

Funkcjonować:

public static String capitalize(String string) {
  final int sl = string.length();
  final StringBuilder sb = new StringBuilder(sl);
  boolean lod = false;
  for(int s = 0; s < sl; s++) {
    final int cp = string.codePointAt(s);
    sb.appendCodePoint(lod ? Character.toLowerCase(cp) : Character.toUpperCase(cp));
    lod = Character.isLetterOrDigit(cp);
    if(!Character.isBmpCodePoint(cp)) s++;
  }
  return sb.toString();
}

Przykładowe wywołanie:

System.out.println(capitalize("An à la carte StRiNg. Surrogate pairs: 𐐪𐐪."));

Wynik:

An À La Carte String. Surrogate Pairs: 𐐂𐐪.

3

Posługiwać się:

    String text = "jon skeet, miles o'brien, old mcdonald";

    Pattern pattern = Pattern.compile("\\b([a-z])([\\w]*)");
    Matcher matcher = pattern.matcher(text);
    StringBuffer buffer = new StringBuffer();
    while (matcher.find()) {
        matcher.appendReplacement(buffer, matcher.group(1).toUpperCase() + matcher.group(2));
    }
    String capitalized = matcher.appendTail(buffer).toString();
    System.out.println(capitalized);

Działa doskonale z toLowerCase -> „Matcher matcher = pattern.matcher (text.toLowerCase ());” (W przypadku hasła takiego jak „JOHN DOE”)
smillien62,

3

Istnieje wiele sposobów konwersji pierwszej litery pierwszego słowa, które jest pisane wielką literą. Mam pomysł. To jest bardzo proste:

public String capitalize(String str){

     /* The first thing we do is remove whitespace from string */
     String c = str.replaceAll("\\s+", " ");
     String s = c.trim();
     String l = "";

     for(int i = 0; i < s.length(); i++){
          if(i == 0){                              /* Uppercase the first letter in strings */
              l += s.toUpperCase().charAt(i);
              i++;                                 /* To i = i + 1 because we don't need to add               
                                                    value i = 0 into string l */
          }

          l += s.charAt(i);

          if(s.charAt(i) == 32){                   /* If we meet whitespace (32 in ASCII Code is whitespace) */
              l += s.toUpperCase().charAt(i+1);    /* Uppercase the letter after whitespace */
              i++;                                 /* Yo i = i + 1 because we don't need to add
                                                   value whitespace into string l */
          }        
     }
     return l;
}

Dziękujemy za próbę dodania odpowiedzi. Jest to rozsądny pomysł, ale zauważ, że istnieją podstawowe funkcje, które już to robią, i kod, który robi to podobnie do tego, co podałeś, a zaakceptowane odpowiedzi już bardzo wyraźnie zarysowują je wszystkie.
David Manheim

2
  package com.test;

 /**
   * @author Prasanth Pillai
   * @date 01-Feb-2012
   * @description : Below is the test class details
   * 
   * inputs a String from a user. Expect the String to contain spaces and    alphanumeric     characters only.
   * capitalizes all first letters of the words in the given String.
   * preserves all other characters (including spaces) in the String.
   * displays the result to the user.
   * 
   * Approach : I have followed a simple approach. However there are many string    utilities available 
   * for the same purpose. Example : WordUtils.capitalize(str) (from apache commons-lang)
   *
   */
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;

  public class Test {

public static void main(String[] args) throws IOException{
    System.out.println("Input String :\n");
    InputStreamReader converter = new InputStreamReader(System.in);
    BufferedReader in = new BufferedReader(converter);
    String inputString = in.readLine();
    int length = inputString.length();
    StringBuffer newStr = new StringBuffer(0);
    int i = 0;
    int k = 0;
    /* This is a simple approach
     * step 1: scan through the input string
     * step 2: capitalize the first letter of each word in string
     * The integer k, is used as a value to determine whether the 
     * letter is the first letter in each word in the string.
     */

    while( i < length){
        if (Character.isLetter(inputString.charAt(i))){
            if ( k == 0){
            newStr = newStr.append(Character.toUpperCase(inputString.charAt(i)));
            k = 2;
            }//this else loop is to avoid repeatation of the first letter in output string 
            else {
            newStr = newStr.append(inputString.charAt(i));
            }
        } // for the letters which are not first letter, simply append to the output string. 
        else {
            newStr = newStr.append(inputString.charAt(i));
            k=0;
        }
        i+=1;           
    }
    System.out.println("new String ->"+newStr);
    }
}

2

Oto prosta funkcja

public static String capEachWord(String source){
    String result = "";
    String[] splitString = source.split(" ");
    for(String target : splitString){
        result += Character.toUpperCase(target.charAt(0))
                + target.substring(1) + " ";
    }
    return result.trim();
}

1
Nie używaj łączenia łańcuchowego do tworzenia długich łańcuchów, jest to boleśnie powolne: stackoverflow.com/questions/15177987/...
Lukas Knuth

2

To tylko kolejny sposób na zrobienie tego:

private String capitalize(String line)
{
    StringTokenizer token =new StringTokenizer(line);
    String CapLine="";
    while(token.hasMoreTokens())
    {
        String tok = token.nextToken().toString();
        CapLine += Character.toUpperCase(tok.charAt(0))+ tok.substring(1)+" ";        
    }
    return CapLine.substring(0,CapLine.length()-1);
}

2

Metoda wielokrotnego użytku dla intiCap:

    public class YarlagaddaSireeshTest{

    public static void main(String[] args) {
        String FinalStringIs = "";
        String testNames = "sireesh yarlagadda test";
        String[] name = testNames.split("\\s");

        for(String nameIs :name){
            FinalStringIs += getIntiCapString(nameIs) + ",";
        }
        System.out.println("Final Result "+ FinalStringIs);
    }

    public static String getIntiCapString(String param) {
        if(param != null && param.length()>0){          
            char[] charArray = param.toCharArray(); 
            charArray[0] = Character.toUpperCase(charArray[0]); 
            return new String(charArray); 
        }
        else {
            return "";
        }
    }
}

2

Oto moje rozwiązanie.

Natknąłem się dziś na ten problem i postanowiłem go przeszukać. Znalazłem odpowiedź Neelama Singha, która była już prawie na miejscu, więc postanowiłem naprawić problem (zepsułem puste ciągi) i spowodowałem awarię systemu.

Metoda, której szukasz, została nazwana capString(String s)poniżej. Okazuje się, że „Tu jest tylko 5 rano” w „To tylko 5 rano tutaj”.

Kod jest dość dobrze skomentowany, więc baw się dobrze.

package com.lincolnwdaniel.interactivestory.model;

    public class StringS {

    /**
     * @param s is a string of any length, ideally only one word
     * @return a capitalized string.
     * only the first letter of the string is made to uppercase
     */
    public static String capSingleWord(String s) {
        if(s.isEmpty() || s.length()<2) {
            return Character.toUpperCase(s.charAt(0))+"";
        } 
        else {
            return Character.toUpperCase(s.charAt(0)) + s.substring(1);
        }
    }

    /**
     *
     * @param s is a string of any length
     * @return a title cased string.
     * All first letter of each word is made to uppercase
     */
    public static String capString(String s) {
        // Check if the string is empty, if it is, return it immediately
        if(s.isEmpty()){
            return s;
        }

        // Split string on space and create array of words
        String[] arr = s.split(" ");
        // Create a string buffer to hold the new capitalized string
        StringBuffer sb = new StringBuffer();

        // Check if the array is empty (would be caused by the passage of s as an empty string [i.g "" or " "],
        // If it is, return the original string immediately
        if( arr.length < 1 ){
            return s;
        }

        for (int i = 0; i < arr.length; i++) {
            sb.append(Character.toUpperCase(arr[i].charAt(0)))
                    .append(arr[i].substring(1)).append(" ");
        }
        return sb.toString().trim();
    }
}

2

1. Strumienie Java 8

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

    return Arrays.stream(str.split("\\s+"))
            .map(t -> t.substring(0, 1).toUpperCase() + t.substring(1))
            .collect(Collectors.joining(" "));
}

Przykłady:

System.out.println(capitalizeAll("jon skeet")); // Jon Skeet
System.out.println(capitalizeAll("miles o'Brien")); // Miles O'Brien
System.out.println(capitalizeAll("old mcdonald")); // Old Mcdonald
System.out.println(capitalizeAll(null)); // null

W tym foo bARcelu Foo Barzastąp map()metodę następującą:

.map(t -> t.substring(0, 1).toUpperCase() + t.substring(1).toLowerCase())

2. String.replaceAll()(Java 9+)

ublic static String capitalizeAll(String str) {
    if (str == null || str.isEmpty()) {
        return str;
    }

    return Pattern.compile("\\b(.)(.*?)\\b")
            .matcher(str)
            .replaceAll(match -> match.group(1).toUpperCase() + match.group(2));
}

Przykłady:

System.out.println(capitalizeAll("12 ways to learn java")); // 12 Ways To Learn Java
System.out.println(capitalizeAll("i am atta")); // I Am Atta
System.out.println(capitalizeAll(null)); // null

3. Tekst Apache Commons

System.out.println(WordUtils.capitalize("love is everywhere")); // Love Is Everywhere
System.out.println(WordUtils.capitalize("sky, sky, blue sky!")); // Sky, Sky, Blue Sky!
System.out.println(WordUtils.capitalize(null)); // null

W przypadku titlecase:

System.out.println(WordUtils.capitalizeFully("fOO bAR")); // Foo Bar
System.out.println(WordUtils.capitalizeFully("sKy is BLUE!")); // Sky Is Blue!

Aby uzyskać szczegółowe informacje, sprawdź ten samouczek .



1
String s="hi dude i                                 want apple";
    s = s.replaceAll("\\s+"," ");
    String[] split = s.split(" ");
    s="";
    for (int i = 0; i < split.length; i++) {
        split[i]=Character.toUpperCase(split[i].charAt(0))+split[i].substring(1);
        s+=split[i]+" ";
        System.out.println(split[i]);
    }
    System.out.println(s);

1
package corejava.string.intern;

import java.io.DataInputStream;

import java.util.ArrayList;

/*
 * wap to accept only 3 sentences and convert first character of each word into upper case
 */

public class Accept3Lines_FirstCharUppercase {

    static String line;
    static String words[];
    static ArrayList<String> list=new ArrayList<String>();

    /**
     * @param args
     */
    public static void main(String[] args) throws java.lang.Exception{

        DataInputStream read=new DataInputStream(System.in);
        System.out.println("Enter only three sentences");
        int i=0;
        while((line=read.readLine())!=null){
            method(line);       //main logic of the code
            if((i++)==2){
                break;
            }
        }
        display();
        System.out.println("\n End of the program");

    }

    /*
     * this will display all the elements in an array
     */
    public static void display(){
        for(String display:list){
            System.out.println(display);
        }
    }

    /*
     * this divide the line of string into words 
     * and first char of the each word is converted to upper case
     * and to an array list
     */
    public static void method(String lineParam){
        words=line.split("\\s");
        for(String s:words){
            String result=s.substring(0,1).toUpperCase()+s.substring(1);
            list.add(result);
        }
    }

}

1

Jeśli wolisz Guava ...

String myString = ...;

String capWords = Joiner.on(' ').join(Iterables.transform(Splitter.on(' ').omitEmptyStrings().split(myString), new Function<String, String>() {
    public String apply(String input) {
        return Character.toUpperCase(input.charAt(0)) + input.substring(1);
    }
}));

1
String toUpperCaseFirstLetterOnly(String str) {
    String[] words = str.split(" ");
    StringBuilder ret = new StringBuilder();
    for(int i = 0; i < words.length; i++) {
        ret.append(Character.toUpperCase(words[i].charAt(0)));
        ret.append(words[i].substring(1));
        if(i < words.length - 1) {
            ret.append(' ');
        }
    }
    return ret.toString();
}

1

Krótki i precyzyjny sposób jest następujący:

String name = "test";

name = (name.length() != 0) ?name.toString().toLowerCase().substring(0,1).toUpperCase().concat(name.substring(1)): name;
--------------------
Output
--------------------
Test
T 
empty
--------------------

Działa bezbłędnie, jeśli spróbujesz zmienić wartość nazwy na trzy wartości. Bez błędów.


co jeśli to więcej niż jedno słowo
luckyguy73
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.