Jak na dużą literę co pierwsza litera słowa w ciągu?

Question

Powiel możliwe:
Capitalize First Char of Each Word in a String Java

mam napis: „Cześć stary dobry świat” i chcę dużymi literami każdą pierwszą literę każdego słowa, a nie cały ciąg z. toUpperCase(). Czy istnieje istniejący pomocnik java, który wykonuje tę pracę?

Answer 1

spojrzeć ACL WordUtils.

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

Answer 2

nie wiem, czy jest to funkcja, ale by wykonać zadanie w przypadku braku exsiting jeden:

String s = "here are a bunch of words"; 

final StringBuilder result = new StringBuilder(s.length()); 
String[] words = s.split("\\s"); 
for(int i=0,l=words.length;i<l;++i) { 
    if(i>0) result.append(" ");  
    result.append(Character.toUpperCase(words[i].charAt(0))) 
     .append(words[i].substring(1)); 

} 

Answer 3

Możesz także zajrzeć do biblioteki StringUtils. Ma mnóstwo fajnych rzeczy.

Answer 4

public String UpperCaseWords(String line) 
{ 
    line = line.trim().toLowerCase(); 
    String data[] = line.split("\\s"); 
    line = ""; 
    for(int i =0;i< data.length;i++) 
    { 
     if(data[i].length()>1) 
      line = line + data[i].substring(0,1).toUpperCase()+data[i].substring(1)+" "; 
     else 
      line = line + data[i].toUpperCase(); 
    } 
    return line.trim(); 
} 

Answer 5

import java.util.Scanner; 
public class CapitolizeOneString { 

    public static void main(String[] args) 
    { 
     Scanner scan = new Scanner(System.in); 
     System.out.print(" Please enter Your word  = "); 
     String str=scan.nextLine(); 

     printCapitalized(str); 
    } // end main() 

    static void printCapitalized(String str) { 
     // Print a copy of str to standard output, with the 
     // first letter of each word in upper case. 
     char ch;  // One of the characters in str. 
     char prevCh; // The character that comes before ch in the string. 
     int i;   // A position in str, from 0 to str.length()-1. 
     prevCh = '.'; // Prime the loop with any non-letter character. 
     for (i = 0; i < str.length(); i++) { 
      ch = str.charAt(i); 
      if (Character.isLetter(ch) && ! Character.isLetter(prevCh)) 
       System.out.print(Character.toUpperCase(ch)); 
      else 
       System.out.print(ch); 
      prevCh = ch; // prevCh for next iteration is ch. 
     } 
     System.out.println(); 
    } 
} // end class 

Answer 6

Oto bardzo prosty, kompaktowe rozwiązanie. str zawiera zmienną tego, co chcesz zrobić z dużymi literami.

StringBuilder b = new StringBuilder(str); 
int i = 0; 
do { 
    b.replace(i, i + 1, b.substring(i,i + 1).toUpperCase()); 
    i = b.indexOf(" ", i) + 1; 
} while (i > 0 && i < b.length()); 

System.out.println(b.toString()); 

Najlepiej działa z StringBuilder ponieważ String jest niezmienna i jest nieefektywne, aby wygenerować nowe struny dla każdego słowa.

Answer 7

Oto kod

String source = "hello good old world"; 
    StringBuffer res = new StringBuffer(); 

    String[] strArr = source.split(" "); 
    for (String str : strArr) { 
     char[] stringArray = str.trim().toCharArray(); 
     stringArray[0] = Character.toUpperCase(stringArray[0]); 
     str = new String(stringArray); 

     res.append(str).append(" "); 
    } 

    System.out.print("Result: " + res.toString().trim()); 

Answer 8

public class WordChangeInCapital{ 

    public static void main(String[] args) 
    { 
     String s="this is string example"; 
     System.out.println(s); 
     //this is input data. 
     //this example for a string where each word must be started in capital letter 
     StringBuffer sb=new StringBuffer(s); 
     int i=0; 
     do{ 
     b.replace(i,i+1,sb.substring(i,i+1).toUpperCase()); 
     i=b.indexOf(" ",i)+1; 
     } while(i>0 && i<sb.length()); 
     System.out.println(sb.length()); 
    } 

} 

Answer 9

package com.raj.samplestring; 

/** 
* @author gnagara 
*/ 
public class SampleString { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     String[] stringArray; 
     String givenString = "ramu is Arr Good boy"; 

     stringArray = givenString.split(" "); 


     for(int i=0; i<stringArray.length;i++){ 
      if(!Character.isUpperCase(stringArray[i].charAt(0))){ 
       Character c = stringArray[i].charAt(0); 
       Character change = Character.toUpperCase(c); 

       StringBuffer ss = new StringBuffer(stringArray[i]); 
       ss.insert(0, change); 
       ss.deleteCharAt(1); 
       stringArray[i]= ss.toString(); 
      } 
     } 
     for(String e:stringArray){ 
      System.out.println(e); 
     } 
    } 
} 

Answer 10

Starając się być bardziej skuteczne niż pamięć dzielenie ciąg na wielu ciągów, a przy użyciu strategii przedstawionej przez Darshana Sri Lance. Ponadto obsługuje całą białą przestrzeń między słowami, a nie tylko znak "".

public static String UppercaseFirstLetters(String str) 
{ 
    boolean prevWasWhiteSp = true; 
    char[] chars = str.toCharArray(); 
    for (int i = 0; i < chars.length; i++) { 
     if (Character.isLetter(chars[i])) { 
      if (prevWasWhiteSp) { 
       chars[i] = Character.toUpperCase(chars[i]);  
      } 
      prevWasWhiteSp = false; 
     } else { 
      prevWasWhiteSp = Character.isWhitespace(chars[i]); 
     } 
    } 
    return new String(chars); 
} 

Answer 11

import org.apache.commons.lang.WordUtils; 

public class CapitalizeFirstLetterInString { 
    public static void main(String[] args) { 
     // only the first letter of each word is capitalized. 
     String wordStr = WordUtils.capitalize("this is first WORD capital test."); 
     //Capitalize method capitalizes only first character of a String 
     System.out.println("wordStr= " + wordStr); 

     wordStr = WordUtils.capitalizeFully("this is first WORD capital test."); 
     // This method capitalizes first character of a String and make rest of the characters lowercase 
     System.out.println("wordStr = " + wordStr); 
    } 
} 

wyjściowa:

To jest pierwsze słowo Capital testowy.

Jest to pierwszy kapitałowy test słów.

Answer 12

Oto proste rozwiązanie:

public class CapitalFirstLetters { 

public static void main(String[] args) { 
    String word = "it's java, baby!"; 
    String[] wordSplit; 
    String wordCapital = ""; 
    wordSplit = word.split(" "); 
    for (int i = 0; i < wordSplit.length; i++) { 
     wordCapital = wordSplit[i].substring(0, 1).toUpperCase() + wordSplit[i].substring(1) + " "; 
    } 
    System.out.println(wordCapital); 
}} 

Answer 13

sString = sString.toLowerCase(); 
sString = Character.toString(sString.charAt(0)).toUpperCase()+sString.substring(1); 

Answer 14

więc znacznie prostsze z regexes:

Pattern spaces=Pattern.compile("\\s+[a-z]");  
Matcher m=spaces.matcher(word);  
StringBuilder capitalWordBuilder=new StringBuilder(word.substring(0,1).toUpperCase()); 
int prevStart=1; 
     while(m.find()) { 
       capitalWordBuilder.append(word.substring(prevStart,m.end()-1)); 
       capitalWordBuilder.append(word.substring(m.end()-1,m.end()).toUpperCase()); 
       prevStart=m.end(); 
     } 
     capitalWordBuilder.append(word.substring(prevStart,word.length())); 

wyjście do wejścia: "To zdanie Weird czapki"

tym zdaniu Ma dziwne czapki

Answer 15

String s = "java is an object oriented programming language.";  
    final StringBuilder result = new StringBuilder(s.length());  
    String words[] = s.split("\\ "); // space found then split it 
    for (int i = 0; i < words.length; i++) 
     { 
    if (i > 0){ 
    result.append(" "); 
    } 
    result.append(Character.toUpperCase(words[i].charAt(0))).append(
       words[i].substring(1)); 
    } 
    System.out.println(result); 

Answer 16

Mój kod po przeczytaniu kilku powyższych odpowiedzi.

/** 
* Returns the given underscored_word_group as a Human Readable Word Group. 
* (Underscores are replaced by spaces and capitalized following words.) 
* 
* @param pWord 
*   String to be made more readable 
* @return Human-readable string 
*/ 
public static String humanize2(String pWord) 
{ 
    StringBuilder sb = new StringBuilder(); 
    String[] words = pWord.replaceAll("_", " ").split("\\s"); 
    for (int i = 0; i < words.length; i++) 
    { 
     if (i > 0) 
      sb.append(" "); 
     if (words[i].length() > 0) 
     { 
      sb.append(Character.toUpperCase(words[i].charAt(0))); 
      if (words[i].length() > 1) 
      { 
       sb.append(words[i].substring(1)); 
      } 
     } 
    } 
    return sb.toString(); 
}