Wie wird das erste Zeichen eines jeden Wortes in einer Zeichenfolge groß geschrieben?
Gibt es eine in Java integrierte Funktion, die das erste Zeichen jedes Words in einem String großschreibt und die anderen nicht beeinflusst?
Beispiele:
jon skeet->Jon Skeetmiles o'Brien->Miles O'Brien(B bleibt Kapital, dies schließt Titelfall aus)old mcdonald->Old Mcdonald*
* (Old McDonald wäre auch zu finden, aber ich erwarte nicht, dass es so intelligent ist.)
Ein kurzer Blick auf die Java-String-Dokumentation zeigt nur toUpperCase() und toLowerCase(), die natürlich nicht das gewünschte Verhalten liefern. Natürlich werden Google-Ergebnisse von diesen beiden Funktionen dominiert. Es scheint ein Rad zu sein, das bereits erfunden worden sein muss, so dass es nicht schaden kann zu fragen, also kann ich es in Zukunft verwenden.
WordUtils.capitalize(str) (aus Apache commons-text )
(Hinweis: Wenn Sie "fOO BAr" benötigen, um "Foo Bar" zu werden, verwenden Sie stattdessen capitalizeFully(..).)
Wenn Sie sich nur Sorgen machen, dass der erste Buchstabe des ersten Wortes groß geschrieben wird:
private String capitalize(final String line) {
return Character.toUpperCase(line.charAt(0)) + line.substring(1);
}
Die folgende Methode konvertiert alle Buchstaben in Groß-/Kleinschreibung, abhängig von ihrer Position in der Nähe eines Leerzeichens oder anderer Sonderzeichen.
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);
}
Versuchen Sie es auf ganz einfache Weise
example givenString = "RAM ist guter Junge"
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();
}
Es wird ausgegeben: Ram Is Good Boy
Ich habe eine kleine Klasse geschrieben, um alle Wörter in einem String groß zu schreiben.
Optional multiple delimiters, jeder mit seinem Verhalten (Groß-/Kleinschreibung vor, nach oder beides, um Fälle wie O'Brian zu behandeln);
Optional Locale;
Bricht nicht mit Surrogate Pairs ab.
Ausgabe:
==================================== 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 À
Hinweis: Der erste Buchstabe wird immer groß geschrieben (bearbeiten Sie die Quelle, wenn Sie dies nicht möchten).
Bitte teilen Sie Ihre Kommentare und helfen Sie mir, Fehler zu finden oder den Code zu verbessern ...
Code:
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;
}
}
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();
Die Verwendung von org.Apache.commons.lang.StringUtils macht es sehr einfach.
capitalizeStr = StringUtils.capitalize(str);
Ich habe eine Lösung in Java 8 gemacht, die IMHO besser lesbar ist.
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(" "));
}
Die Gist für diese Lösung finden Sie hier: https://Gist.github.com/Hylke1982/166a792313c5e2df9d31
Mit diesem einfachen Code :
String example="hello";
example=example.substring(0,1).toUpperCase()+example.substring(1, example.length());
System.out.println(example);
Ergebnis: Hallo
Ich verwende die folgende Funktion. Ich denke es ist schneller in der Leistung.
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();
}
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());
}
Dies kann nützlich sein, wenn Sie Titel groß schreiben müssen. Es wird jede durch " " begrenzte Teilzeichenfolge großgeschrieben, mit Ausnahme der angegebenen Zeichenfolgen wie "a" oder "the". Ich habe es noch nicht ausgeführt, weil es zu spät ist, sollte aber auch in Ordnung sein. Verwendet an einem Punkt Apache Commons StringUtils.join() . Sie können es durch eine einfache Schleife ersetzen, wenn Sie möchten.
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
}
Verwenden Sie die Split-Methode, um Ihre Zeichenfolge in Wörter aufzuteilen. Verwenden Sie dann die integrierten Zeichenfolgenfunktionen, um jedes Wort groß zu schreiben, und fügen Sie es anschließend zusammen.
Pseudocode (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
Am Ende sieht String so aus wie .__ "Der Satz, auf den Sie Caps anwenden möchten"
Es gibt viele Möglichkeiten, den ersten Buchstaben des ersten Wortes, das großgeschrieben wird, umzuwandeln. Ich habe eine Idee. Es ist sehr einfach:
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;
}
Von Java 9+
sie können String::replceAll wie folgt verwenden:
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);
}
Beispiel:
upperCaseAllFirstCharacter("hello this is Just a test");
Ausgaben
Hello This Is Just A Test
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());
}
Hier ist eine einfache Funktion
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();
}
Ich entschied mich für eine weitere Lösung, um Wörter in einer Zeichenfolge groß zu schreiben:
- wörter werden hier als benachbarte Buchstaben oder Ziffern definiert;
- ersatzpaare sind ebenfalls vorhanden;
- der Code wurde auf Leistung optimiert. und
- es ist immer noch kompakt.
Funktion:
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();
}
Beispielanruf:
System.out.println(capitalize("An à la carte StRiNg. Surrogate pairs: ????????."));
Ergebnis:
An À La Carte String. Surrogate Pairs: ????????.
Benutzen:
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);
Wiederverwendbare Methode für 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 "";
}
}
}
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);
}
}
Hier ist meine Lösung.
Ich bin heute Abend auf dieses Problem gestoßen und habe mich entschieden, es zu durchsuchen. Ich fand eine Antwort von Neelam Singh, die fast da war, also entschied ich mich, das Problem zu beheben (brach an leeren Zeichenketten) und verursachte einen Systemausfall.
Die von Ihnen gesuchte Methode wird im Folgenden als capString(String s) bezeichnet. Es macht aus "Es ist erst 5 Uhr hier" in "Es ist nur 5 Uhr hier".
Der Code ist ziemlich gut kommentiert, also viel Spaß.
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();
}
}
Dies ist nur eine andere Möglichkeit, dies zu tun:
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);
}
Dieser arbeitet für den Nachnamen-Fall ...
Mit verschiedenen Arten von Trennzeichen, und es behält das gleiche Trennzeichen bei:
jean-Frederic -> Jean-Frederic
jean Frederic -> Jean Frederic
Der Code funktioniert mit der GWT-Clientseite.
public static String capitalize (String givenString) {
String Separateur = " ,.-;";
StringBuffer sb = new StringBuffer();
boolean ToCap = true;
for (int i = 0; i < givenString.length(); i++) {
if (ToCap)
sb.append(Character.toUpperCase(givenString.charAt(i)));
else
sb.append(Character.toLowerCase(givenString.charAt(i)));
if (Separateur.indexOf(givenString.charAt(i)) >=0)
ToCap = true;
else
ToCap = false;
}
return sb.toString().trim();
}
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);
}
}
}
Wenn Sie Guave bevorzugen ...
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);
}
}));
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);
Für diejenigen, die Velocity in Ihrer MVC verwenden, können Sie die capitalizeFirstLetter()-Methode aus der StringUtils-Klasse verwenden.
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();
}
Der kurze und präzise Weg ist wie folgt:
String name = "test";
name = (name.length() != 0) ?name.toString().toLowerCase().substring(0,1).toUpperCase().concat(name.substring(1)): name;
-------------------- Output -------------------- Test T empty --------------------
Es funktioniert fehlerfrei, wenn Sie versuchen, den Namenswert in drei Werte zu ändern. Fehlerfrei.
Versuche dies:
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();
}
Ich benutze wordUppercase(String s) aus der Raindrop-Library . Da dies meine Bibliothek ist, hier die einzige Methode:
/**
* Set set first letter from every Word uppercase.
*
* @param s - The String wich you want to convert.
* @return The string where is the first letter of every Word uppercase.
*/
public static String wordUppercase(String s){
String[] words = s.split(" ");
for (int i = 0; i < words.length; i++) words[i] = words[i].substring(0, 1).toUpperCase() + words[i].substring(1).toLowerCase();
return String.join(" ", words);
}
Ich hoffe es hilft :)
Hier ist RxJava Lösung für das Problem
String title = "this is a title";
StringBuilder stringBuilder = new StringBuilder();
Observable.fromArray(title.trim().split("\\s"))
.map(Word -> Word.substring(0, 1).toUpperCase() + Word.substring(1).toLowerCase())
.toList()
.map(wordList -> {
for (String Word : wordList) {
stringBuilder.append(Word).append(" ");
}
return stringBuilder.toString();
})
.subscribe(result -> System.out.println(result));
Ich mag die For-Loop-Karte jedoch noch nicht.
s.toLowerCase().trim();
result += Character.toUpperCase(s.charAt(0));
result += s.substring(1, s.indexOf(" ") + 1);
s = s.substring(s.indexOf(" ") + 1);
do {
if (s.contains(" ")) {
result += " ";
result += Character.toUpperCase(s.charAt(0));
result += s.substring(1, s.indexOf(" "));
s = s.substring(s.indexOf(" ") + 1);
} else {
result += " ";
result += Character.toUpperCase(s.charAt(0));
result += s.substring(1);
break;
}
} while (true);
System.out.println(result);
Ich möchte nur eine alternative Lösung für das Problem hinzufügen, indem ich nur Java-Code verwende. Keine extra Bibliothek
public String Capitalize(String str) {
String tt = "";
String tempString = "";
String tempName = str.trim().toLowerCase();
String[] tempNameArr = tempName.split(" ");
System.out.println("The size is " + tempNameArr.length);
if (tempNameArr.length > 1) {
for (String t : tempNameArr) {
tt += Capitalize(t);
tt += " ";
}
tempString = tt;
} else {
tempString = tempName.replaceFirst(String.valueOf(tempName.charAt(0)), String.valueOf(tempName.charAt(0)).toUpperCase());
}
return tempString.trim();
}
public void capitaliseFirstLetterOfEachWord()
{
String value="this will capitalise first character of each Word of this string";
String[] wordSplit=value.split(" ");
StringBuilder sb=new StringBuilder();
for (int i=0;i<wordSplit.length;i++){
sb.append(wordSplit[i].substring(0,1).toUpperCase().
concat(wordSplit[i].substring(1)).concat(" "));
}
System.out.println(sb);
}
String text="hello";
StringBuffer sb=new StringBuffer();
char[] ch=text.toCharArray();
for(int i=0;i<ch.length;i++){
if(i==0){
sb.append(Character.toUpperCase(ch[i]));
}
else{
sb.append(ch[i]);
}
}
text=sb.toString();
System.out.println(text);
}
Hier ist ein kleines Programm, mit dem ich jeden ersten Buchstaben Word in jedem Unterordner eines übergeordneten Verzeichnisses groß geschrieben habe.
private void capitalize(String string)
{
List<String> delimiters = new ArrayList<>();
delimiters.add(" ");
delimiters.add("_");
File folder = new File(string);
String name = folder.getName();
String[] characters = name.split("");
String newName = "";
boolean capitalizeNext = false;
for (int i = 0; i < characters.length; i++)
{
String character = characters[i];
if (capitalizeNext || i == 0)
{
newName += character.toUpperCase();
capitalizeNext = false;
}
else
{
if (delimiters.contains(character)) capitalizeNext = true;
newName += character;
}
}
folder.renameTo(new File(folder.getParent() + File.separator + newName));
}
Da niemand regexp verwendet hat, machen wir es mit regexp. Diese Lösung ist zum Spaß. :) (Update: eigentlich habe ich gerade entdeckt, dass es eine Antwort mit Regexx gibt, trotzdem möchte ich diese Antwort an Ort und Stelle belassen, da sie besser aussehend :)):
public class Capitol
{
public static String now(String str)
{
StringBuffer b = new StringBuffer();
Pattern p = Pattern.compile("\\b(\\w){1}");
Matcher m = p.matcher(str);
while (m.find())
{
String s = m.group(1);
m.appendReplacement(b, s.toUpperCase());
}
m.appendTail(b);
return b.toString();
}
}
Verwendungszweck
Capitol.now("ab cd"));
Capitol.now("winnie the Pooh"));
Capitol.now("please talk loudly!"));
Capitol.now("miles o'Brien"));
Ich hatte die Anforderung, eine generische toString (Object obj) -Helperklassenfunktion zu erstellen, bei der ich die Feldnamen in Methodennamen - getXXX () des übergebenen Objekts umwandeln musste.
Hier ist der Code
/**
* @author DPARASOU
* Utility method to replace the first char of a string with uppercase but leave other chars as it is.
* ToString()
* @param inStr - String
* @return String
*/
public static String firstCaps(String inStr)
{
if (inStr != null && inStr.length() > 0)
{
char[] outStr = inStr.toCharArray();
outStr[0] = Character.toUpperCase(outStr[0]);
return String.valueOf(outStr);
}
else
return inStr;
}
Und mein Dienstprogramm toString () ist so
public static String getToString(Object obj)
{
StringBuilder toString = new StringBuilder();
toString.append(obj.getClass().getSimpleName());
toString.append("[");
for(Field f : obj.getClass().getDeclaredFields())
{
toString.append(f.getName());
toString.append("=");
try{
//toString.append(f.get(obj)); //access privilege issue
toString.append(invokeGetter(obj, firstCaps(f.getName()), "get"));
}
catch(Exception e)
{
e.printStackTrace();
}
toString.append(", ");
}
toString.setCharAt(toString.length()-2, ']');
return toString.toString();
}
Ich habe diese kleine Klasse erstellt, mit der jedes Wort in einem Satz kapituliert werden kann. Sie können das Worttrennzeichen in der Zeichenfolge ändern, wenn dies kein Leerzeichen ist.
package com.ecnews.ecnews_v01.Helpers;
public class Capitalize {
String sentence;
String separator = " ";
public Capitalize(String sentence) {
this.sentence = sentence;
}
public void setSeparator(String separator) {
this.separator = separator;
}
public String getCapitalized() {
StringBuilder capitalized = new StringBuilder("");
for (String Word : sentence.split(separator)) {
capitalized.append(separator+Character.toUpperCase(Word.charAt(0)) + Word.substring(1));
}
return capitalized.toString().trim();
}
}
Beispiel:
String sourceName = new Capitalize("this is a test").getCapitalized();
sourceName lautet "Dies ist ein Test"
dies ist eine andere Art und Weise, die ich getan habe
StringBuilder str=new StringBuilder("pirai sudie test test");
str.setCharAt(0,Character.toUpperCase(str.charAt(0)));
for(int i=str.length()-1;i>=0;i--)
{
if(Character.isSpaceChar(str.charAt(i)))
str.setCharAt(i+1,Character.toUpperCase(str.charAt(i+1)));
}
System.out.println(str);
public static void main(String[] args) throws IOException {
String words = "this is a test";
System.out.println(Arrays.asList(words.split(" ")).stream().reduce("",(a, b)->(a + " " + b.substring(0, 1).toUpperCase() + b.substring(1))));
}
}
Hier streben wir eine perfekte Großschreibung von Word an
public static void main(String[] args) {
String input ="my name is ranjan";
String[] inputArr = input.split(" ");
for(String Word : inputArr) {
System.out.println(Word.substring(0, 1).toUpperCase()+Word.substring(1,Word.length()));
}
}
}
// Ausgabe: Mein Name ist Ranjan
Simple answer by program:
public class StringCamelCase {
public static void main(String[] args) {
String[] articles = {"the ", "a ", "one ", "some ", "any "};
String[] result = new String[articles.length];
int i = 0;
for (String string : articles) {
result[i++] = toUpercaseForstChar(string);
}
for (String string : result) {
System.out.println(string);
}
}
public static String toUpercaseForstChar(String string){
return new String(new char[]{string.charAt(0)}).toUpperCase() + string.substring(1,string.length());
}
}
Hier ist die Kotlin-Version desselben Problems:
fun capitalizeFirstLetterOfEveryWord(text: String): String
{
if (text.isEmpty() || text.isBlank())
{
return ""
}
if (text.length == 1)
{
return Character.toUpperCase(text[0]).toString()
}
val textArray = text.split(" ")
val stringBuilder = StringBuilder()
for ((index, item) in textArray.withIndex())
{
// If item is empty string, continue to next item
if (item.isEmpty())
{
continue
}
stringBuilder
.append(Character.toUpperCase(item[0]))
// If the item has only one character then continue to next item because we have already capitalized it.
if (item.length == 1)
{
continue
}
for (i in 1 until item.length)
{
stringBuilder
.append(Character.toLowerCase(item[i]))
}
if (index < textArray.lastIndex)
{
stringBuilder
.append(" ")
}
}
return stringBuilder.toString()
}