문자열에서 각 단어의 첫 문자를 대문자로 표시하는 방법


421

문자열에있는 각 단어의 첫 문자를 대문자로 바꾸고 다른 단어에는 영향을주지 않는 함수가 Java에 내장되어 있습니까?

예 :

  • jon skeet -> Jon Skeet
  • miles o'Brien-> Miles O'Brien(B는 대문자로 유지되며 제목은 제외됨)
  • old mcdonald-> Old Mcdonald*

* ( Old McDonald나도 찾을 수 있지만, 그것이 똑똑하다고는 생각하지 않습니다.)

상기 얼핏 자바 문자열 문서는 오직 계시 toUpperCase()toLowerCase()물론 원하는 동작을 제공하지 않는. 당연히 Google 결과는이 두 기능에 의해 좌우됩니다. 그것은 이미 발명 된 바퀴처럼 보입니다. 그래서 나중에 사용할 수 있도록 물어 볼 수 없었습니다.


18
무엇에 대해 old mcdonald? 그럴까요 Old McDonald?
Bart Kiers

2
나는 그 기능이 그렇게 똑똑하다고는 생각하지 않는다. (하나라도 있으면 기뻐할 것입니다.) 공백 후 첫 글자 만 표시하고 나머지는 무시하십시오.
WillfulWizard


1
어쨌든 사실 이후에 이름 대문자를 올바르게 처리하는 알고리즘을 찾을 수 없을 것입니다. 어느 것이 올바른지 알 방법이 없습니다. 그래도 폰 노이만과 같은 일부 이름은 잘못 될 수 있지만 수행 한 작업을 수행하는 것이 좋습니다.
Dave DuPlantis 2016 년

버거 킹 체험 ...
Magno C

답변:


732

WordUtils.capitalize(str)( 아파치 공통 텍스트에서 )

(참고 : 필요하면 "fOO BAr"되기 위해 "Foo Bar", 다음 사용하는 capitalizeFully(..)대신)


5
나는 당신이 WordUtils.capitalize (str)을 의미한다고 생각합니다. 자세한 내용은 API를 참조하십시오.
Hans Doggen 2009

84
커먼즈 라이브러리를 참조하는 답변을 항상 투표한다는 철학을 유지했습니다.
Ravi Wallau

11
첫 번째가 아닌 문자를 소문자로 바꾸려면 capitalizeFully (str)를 사용하십시오.
Umesh Rajbhandari

5
이 솔루션은 정말 맞 습니까? 내 의견으로는 아니다! "LAMborghini"를 대문자로 사용하려면 끝에 "Lamborghini"가 필요합니다. WordUtils.capitalizeFully(str)솔루션도 마찬가지 입니다.
basZero

3
@BasZero 그것은 질문에 대한 정답입니다. 나는 정식 버전을 주석으로 포함시킬 것이다.
Bozho

229

첫 단어의 첫 글자 만 대문자로 표시되는 것이 걱정되는 경우 :

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

3
이것은 첫 단어의 첫 글자 만 바꾼다
Chrizzz

28
실제로 이것은 나의 의도였다.
Nick Bolton

13
@nbolton-그러나 그것은 질문의 의도를 명시 적으로 무시하고 그 예에서 주어진 경우에 실패합니다-그리고 그것은 이전에 주어진 대답에 거의 또는 전혀 추가하지 않습니다!
David Manheim

17
이 코드는 충돌에 안전하지 않습니다! linenull이거나 길이가 <2 인 것을 상상해보십시오 .
stk

1
여전히 복귀 Character.toUpperCase (word.charAt (0)) + word.substring (1) .toLowerCase ()
Exceptyon

72

다음 방법은 공백이나 다른 특수 문자 근처의 위치에 따라 모든 문자를 대문자 / 소문자로 변환합니다.

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

루프 조건을 개선하고 단순화합니다 if(Character.isLetter(chars[i])) { if(!found) { chars[i] = Character.toUpperCase(chars[i]); } found = true; } else { found = false; }.
bancer

@bancer, 예를 들어 대문자가 뒤 따르지 않는 문자를 제어 할 수 없습니다.
True Soft

@TrueSoft, 나는 당신을 이해하지 못합니다. 대문자 뒤에 나오는 문자를 제어해야하는 이유는 무엇입니까? 내가 이해했듯이 앞의 문자가 문자가 아니며 나의 예가 그것을 보장합니다. if-else-if 블록을 if-else 블록으로 바꾸고 테스트를 실행하십시오.
bancer 2016

@TrueSoft, 명확성을 위해 이름 found을으로 바꾸겠습니다 previousCharIsLetter.
bancer 2016

9
나는 가끔 공용 라이브러리를 사용하지 않는 답변을 얻는 것을 좋아합니다. 왜냐하면 때때로 그것을 사용할 수 없기 때문입니다.
Heckman

38

이 간단한 방법을 사용해보십시오

예 givenString = "ram is good boy"

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

다음과 같이 출력됩니다 : Ram Is Good Boy


1
이 코드는 충돌에 우리의 서버를 발생 : java.lang.StringIndexOutOfBoundsException : 문자열 색인이 범위를 벗어 : 0
Chrizzz

32
@Chrizzz는 테스트하지 않은 코드를 커밋하지 않습니다. 빈 문자열을 제공하면 충돌이 발생합니다. 니람이 아니라 네 잘못이야
초에 Reinherd

1
끝에 공백이 있으면 충돌이 발생합니다. 먼저 trim ()을 추가하고 문자열을 공백으로 분할합니다. 그것은 완벽하게 작동했습니다
Hanuman

누군가 Kotlin 버전을 찾고있는 경우 여기에 있습니다 : stackoverflow.com/a/55390188/1708390
Bugs Happen Happen

16

문자열의 모든 단어를 대문자로하기 위해 작은 클래스를 작성했습니다.

선택 사항 multiple delimiters, 각 행동을 가진 사람 (같은 경우를 처리하기 위해, 전에, 후에 또는 모두 대문자로 O'Brian);

선택 사항 Locale;

로 나누지 마십시오 Surrogate Pairs.

라이브 데모

산출:

====================================
 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 À

참고 : 첫 글자는 항상 대문자로 표시됩니다 (원치 않는 경우 소스 편집).

의견을 공유하고 버그를 찾거나 코드를 개선 할 수 있도록 도와주세요 ...

암호:

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
흠, for 루프의 두 번째 줄은 다음과 같아야합니다. toBeCapped + = ""+ capLetter + tokens [i] .substring (1, tokens [i] .length ());
jengelsma 2016 년

1
그러나이 솔루션은 처음에 공백을 추가합니다. 따라서 왼쪽 트림을 수행해야 할 수도 있습니다.
Kamalakannan J

13

IMHO가 더 읽기 쉬운 Java 8 솔루션을 만들었습니다.

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

이 솔루션의 요지는 여기에서 찾을 수 있습니다 : https://gist.github.com/Hylke1982/166a792313c5e2df9d31


10

사용 org.apache.commons.lang.StringUtils하면 매우 간단합니다.

capitalizeStr = StringUtils.capitalize(str);

2
@Ash StringUtils.capitalise(str)는 더 이상 사용되지 않습니다. 참조 : commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/...
Navigatron

이것은 문자열에서 각 단어의 첫 번째 문자가 아닌 문자열의 첫 번째 문자 만 대문자로 표시합니다. 이 평민 랭에서 평민 텍스트로 이동 때문에 WordUtils는 사용되지 않습니다 commons.apache.org/proper/commons-text/javadocs/api-release/org/...
opticyclic

작은 작업에 외부 라이브러리를 사용하는 것은 좋지 않습니다.
스택 오버플로

7

이 간단한 코드로 :

String example="hello";

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

System.out.println(example);

결과 : 안녕하세요


6
당신이 두 번째 하위 문자열와 toLowerCase ()를 사용하여야하므로 안녕을 기대했던 HELLO 대해이 HELLO을 반환하지만
Trikaldarshi

5

다음 기능을 사용하고 있습니다. 성능이 더 빠르다고 생각합니다.

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
+ = 대신 연결할 때 항상 StringBuilder를 사용하십시오.
chitgoks

2
왜 더 빠르다고 생각합니까?
피터 Mortensen

5

Java 9 이상에서

다음 String::replaceAll과 같이 사용할 수 있습니다 :

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

예 :

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

출력

Hello This Is Just A Test

4

Split 메서드를 사용하여 문자열을 단어로 나눈 다음 기본 제공 문자열 함수를 사용하여 각 단어를 대문자로 한 다음 함께 추가하십시오.

의사 코드 (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

마지막 문자열은 "캡을 적용하려는 문장"과 같습니다.


4

타이틀을 대문자로 사용해야하는 경우 유용 할 수 있습니다. 그것은에 의해 구분 된 각각의 문자열 대문자 " "와 같은 특정 문자열을 제외하고, "a"또는 "the". 늦었 기 때문에 아직 실행하지 않았지만 괜찮을 것입니다. Apache Commons 사용StringUtils.join()한 번에 를 합니다. 원하는 경우 간단한 루프로 대체 할 수 있습니다.

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
}

문자열에 공백이 두 개 있으면 입력이 바보이지만 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());
}

스택 오버플로에 오신 것을 환영합니다! 일반적으로 코드의 목적과 다른 언어를 도입하지 않고 문제를 해결하는 이유에 대한 설명이 포함되어 있으면 답변이 훨씬 유용합니다.
Neuron

가장 간단한 솔루션이며 외부 라이브러리 사용을 피합니다
Billyjoker

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

이것은 나와 같은 초보자에게 가장 간단하고 기본적이며 최상의 답변입니다!
abhishah901

3

문자열로 단어를 대문자로 만들기위한 하나 이상의 솔루션을 추가하기로 결정했습니다.

  • 여기서 단어는 인접한 문자 또는 숫자로 정의됩니다.
  • 대리 쌍도 제공됩니다.
  • 코드는 성능에 최적화되었습니다. 과
  • 여전히 작습니다.

함수:

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

호출 예 :

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

결과:

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

3

사용하다:

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

toLowerCase-> "Matcher matcher = pattern.matcher (text.toLowerCase ());"와 완벽하게 작동합니다. ( "JOHN DOE"와 같은 항목 텍스트)
smillien62

3

첫 글자의 첫 글자를 대문자로 변환하는 방법은 여러 가지가 있습니다. 나는 아이디어가. 매우 간단합니다 :

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

답변을 추가해 주셔서 감사합니다. 이것은 합리적인 아이디어이지만 이미이를 수행하는 기본 기능과 사용자가 제공 한 것과 유사한 기능을 수행하는 코드가 있으며 허용 된 답변은 이미 모든 기능을 매우 명확하게 설명합니다.
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

간단한 기능은 다음과 같습니다

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
긴 문자열을 만들기위한 문자열 concation를 사용하지 마십시오, 그것은 고통스럽게 느린 : stackoverflow.com/questions/15177987/...
루카스 크 누스

2

이것은 또 다른 방법입니다.

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

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

여기 내 해결책이 있습니다.

오늘 밤이 문제를 겪고 검색하기로 결정했습니다. 나는 Neelam Singh의 답변을 거의 찾았으므로 문제를 해결하기로 결정하고 (빈 문자열이 끊어짐) 시스템 충돌을 일으켰습니다.

찾고있는 방법의 이름은 capString(String s)다음과 같습니다. "오전 5시입니다"는 "오전 5시"입니다

코드는 잘 주석 처리되어 있으므로 즐기십시오.

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

예 :

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

foo bAR위해 메소드를 다음으로 Foo Bar바꾸십시오 map().

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

2. String.replaceAll()(자바 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));
}

예 :

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. 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

제목의 경우 :

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

자세한 내용은 이 튜토리얼을 확인 하십시오 .



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

구아바를 선호한다면 ...

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

짧고 정확한 방법은 다음과 같습니다.

String name = "test";

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

이름 값을 3 개의 값으로 변경하려고하면 오류없이 작동합니다. 오류가 없습니다.


하나 이상의 단어
라면
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.