Java를 사용 String하여 사용자로부터 입력을 받고 있습니다. 이 입력의 첫 글자를 대문자로 만들려고합니다.

나는 이것을 시도했다 :

String name;

BufferedReader br = new InputStreamReader(System.in);

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

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

이 컴파일러 오류가 발생했습니다 :

• 유형 불일치 : InputStreamReader에서 BufferedReader로 변환 할 수 없습니다

• 기본 유형 char에서 toUppercase ()를 호출 할 수 없습니다.

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

예를 들면 다음과 같습니다.

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(..) 에서 평민 - 랭

문자열의 첫 글자를 대문자로하는 더 짧고 빠른 버전 코드는 다음과 같습니다.

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

의 가치 name는"Stackoverflow"

Apache의 공통 라이브러리를 사용하십시오. 이러한 것들로부터 당신의 두뇌를 해방하고 Null Pointer & Index Out of Bound 예외를 피하십시오

1 단계:

build.gradle의존성 을 두어 Apache의 공통 lang 라이브러리를 가져옵니다.

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

2 단계:

문자열이 모두 소문자인지 확실하거나 첫 글자를 초기화하는 것만 필요하면 직접 전화하십시오.

StringUtils.capitalize(yourString);

당신은 단지 첫 번째 문자가이 일을 같이 대문자로되어 있는지 확인하려면 enum전화 toLowerCase()먼저하고 던질 것이다 것을 명심 NullPointerException입력 문자열이 null 인 경우.

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

아파치에서 제공하는 더 많은 샘플이 있습니다. 예외가 없습니다

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

노트 :

WordUtils이 라이브러리에도 포함되어 있지만 더 이상 사용되지 않습니다. 제발 하지 않는 것을 사용합니다.

자바:

모든 문자열을 대문자로하는 도우미 메소드 일뿐입니다.

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

그 후 단순히 전화 str = capitalize(str)

코 틀린 :

str.capitalize()

당신이하고 싶은 것은 아마도 이것입니다 :

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

(첫 번째 문자를 대문자로 변환하고 원래 문자열의 나머지를 추가합니다)

또한 입력 스트림 리더를 작성하지만 행을 읽지 마십시오. 따라서 name항상 있습니다 null.

이것은 작동해야합니다 :

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)에서 아파치 코 몬즈 .

아래 솔루션이 작동합니다.

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

기본 char에 toUpperCase ()를 사용할 수는 없지만 전체 문자열을 대문자로 만든 다음 첫 번째 문자를 가져온 다음 위의 그림과 같이 하위 문자열을 추가 할 수 있습니다.

사용하십시오 WordUtils.capitalize(str).

가장 짧음 :

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

나를 위해 일했다.

문자열을 소문자로 설정 한 다음 첫 글자를 다음과 같이 대문자로 설정하십시오.

    userName = userName.toLowerCase();

그런 다음 첫 글자를 대문자로 표시하십시오.

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

하위 문자열은 더 큰 문자열 조각을 얻은 다음 다시 결합합니다.

무엇에 대한 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);
    }
}

대문자로 된 첫 글자를 모두 얻으려면이 유틸리티 방법을 사용하십시오.

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

당신은 또한 이것을 시도 할 수 있습니다 :

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

이것은 하위 문자열을 사용하는 것보다 낫습니다. (그러나 작은 줄은 걱정하지 마십시오)

당신이 사용할 수있는 substring() .

그러나 두 가지 경우가 있습니다.

사례 1

경우 String당신은 사람이 읽을 수하기위한 것입니다 활용되어, 당신은 또한 기본 로케일을 지정해야합니다 :

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

사례 2

String대문자를 사용하는 것이 기계가 읽을 수있는 것이면 Locale.getDefault()반환되는 문자열이 다른 지역에서 일치하지 않으므로 항상 같은 로케일을 지정하므로 사용하지 마십시오 (예 :toUpperCase(Locale.ENGLISH) ). 이를 통해 내부 처리에 사용하는 문자열이 일관되게되어 찾기 어려운 버그를 피할 수 있습니다.

참고 : 지정할 필요가 없습니다 Locale.getDefault()에 대한 toLowerCase()이 자동으로 수행 될 때,.

안드로이드 스튜디오에서

이 의존성을 당신의 build.gradle (Module: app)

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

이제 사용할 수 있습니다

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

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

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

SPRING 을 사용하는 경우 :

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


    return capitalize(name);

참고 : Apache Common Lang 종속성이 이미있는 경우 다른 답변에서 제안한대로 StringUtils.capitalize를 사용하는 것이 좋습니다.

구현 : https://github.com/spring-projects/spring-framework/blob/64440a5f04a17b3728234afaa89f57766768decb/spring-core/src/main/java/org/springframework/util/StringUtils.java#L535-L555

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

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

    }

}

이것은 단지 당신이 틀리지 않았다는 것을 보여주기위한 것입니다.

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

참고 : 이것이 최선의 방법은 아닙니다. 이것은 OP를 사용하여 수행 할 수 있음을 보여주기위한 charAt()것입니다. ;)

이 작동합니다

char[] array = value.toCharArray();

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

String result = new String(array);

다음 코드를 사용할 수 있습니다 :

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

}

이거 한번 해봐

이 방법은 "hello world"라는 단어를 고려하여이 방법을 "Hello World"로 바꾸어 각 단어의 시작 부분을 대문자로합니다.

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

    }

주어진 답은 한 단어의 첫 글자 만 대문자로 표기 한 것입니다. 다음 코드를 사용하여 전체 문자열을 대문자로 만드십시오.

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

출력 : This Is A Random String

입력이 대문자 인 경우 다음을 사용하십시오.

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

입력이 소문자 인 경우 다음을 사용하십시오.

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

ACL WordUtils를 살펴보십시오.

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

다음 코드를 사용할 수 있습니다 :

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

}

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

사용하기 commons.lang.StringUtils가장 좋은 대답하는 것입니다 :

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

StringBuffer로 문자열을 감싸기 때문에 훌륭합니다. 원하는 경우 동일한 인스턴스를 사용하여 StringBuffer를 조작 할 수 있습니다.

또 다른 예는 사용자 입력의 첫 글자를 대문자로 만드는 방법입니다.

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