Czy istnieje metoda konwersji ciągu znaków na wielkość liter?

99

Czy są dostępne jakieś wbudowane metody konwertowania ciągu znaków na format wielkości liter?

TylerH
źródło
3
Wszyscy czytający to pytanie: uważajcie, że wiele odpowiedzi, które zostały tutaj poddane najwyżej głosowaniu, NIE DZIAŁA PRAWIDŁOWO dla wszystkich języków. Potrzebujesz biblioteki obsługującej i18n do poprawnego znakowania tytułów, takiej jak ICU4J (patrz odpowiedź Daniela F).
sffc

Odpowiedzi:

106

Apache Commons StringUtils.capitalize () lub Commons Text WordUtils.capitalize ()

np. WordUtils.capitalize("i am FINE") = "I Am FINE"z dokumentu WordUtils

aberrant80
źródło
14
WordUtils.capitalizeFully () był dla mnie lepszy, ponieważ daje: WordUtils.capitalizeFully ("i am FINE") = "I Am Fine"
theINtoy
2
Tylko mała aktualizacja, WordUtils trafił do Commons Text i został wycofany w Commons Lang
msrd0
Wiosna też maStringUtils.capitalise()
OrangeDog
@OrangeDog masz na myśli capitalize()?
TylerH
@TylerH tak, autokorekta dotarła do tego
OrangeDog
60

W klasie String języka Java nie ma metod capitalize () ani titleCase (). Masz dwie możliwości:

 StringUtils.capitalize(null)  = null
 StringUtils.capitalize("")    = ""
 StringUtils.capitalize("cat") = "Cat"
 StringUtils.capitalize("cAt") = "CAt"
 StringUtils.capitalize("'cat'") = "'cat'"
  • write (jeszcze inna) statyczna metoda pomocnicza toTitleCase ()

Przykładowa realizacja

public static String toTitleCase(String input) {
    StringBuilder titleCase = new StringBuilder(input.length());
    boolean nextTitleCase = true;

    for (char c : input.toCharArray()) {
        if (Character.isSpaceChar(c)) {
            nextTitleCase = true;
        } else if (nextTitleCase) {
            c = Character.toTitleCase(c);
            nextTitleCase = false;
        }

        titleCase.append(c);
    }

    return titleCase.toString();
}

Testcase

    System.out.println(toTitleCase("string"));
    System.out.println(toTitleCase("another string"));
    System.out.println(toTitleCase("YET ANOTHER STRING"));

wyjścia:

Strunowy
Kolejna struna
JESZCZE KOLEJNA STRUNA
dfa
źródło
1
Jest to niezła procedura, ale zawodzi w bardziej ogólnym przypadku, w którym ciągi znaków mogą reprezentować nazwy. W takim przypadku wielkie litery musiałyby również występować po apostrofach i łącznikach. Na przykład. O'Connor i J. Wilkes-Booth. Oczywiście inne języki mogą mieć dodatkowe reguły dotyczące wielkości liter.
scottb
... Gdyby to zawierało, czy nie wymagałoby przeszukania całego słownika tylko po to, aby sprawdzić, czy bieżące słowo jest nazwą? Wydaje się to trochę za dużo jak na jedną metodę.
MMJZ
Ten kod jest prawie w porządku, ponieważ niektóre nazwy mogą mieć prepositons, takie jak de, del, della, dei, da, jak w Maria del Carmen, Maria da Silva, Maria della Salute itp. Coderanch.com/t/35096/Programming/ ...
Junior Mayhé
Czy to nie zrywa z apostrofem? Na przykład co z O'Brianem.
sproketboy,
1
Uwaga: aby uniknąć zmiany rozmiaru w kategorii używane wewnętrznie char[]w StringBuilderSugeruję użyciunew StringBuilder(input.length())
Lino
38

Jeśli mogę przedstawić swoje podejście do rozwiązania ...

Poniższa metoda jest oparta na tej, którą opublikował dfa. Wprowadza następującą zasadniczą zmianę (która jest dopasowana do rozwiązania, którego potrzebowałem w tamtym czasie): wymusza na wszystkich znakach w ciągu wejściowym małe litery, chyba że jest bezpośrednio poprzedzone „ogranicznikiem aktywnym”, w którym to przypadku znak jest wymuszany na duże litery.

Głównym ograniczeniem mojej procedury jest to, że zakłada ona, że ​​„przypadek tytułu” jest jednolicie zdefiniowany dla wszystkich lokalizacji i jest reprezentowany przez te same konwencje dotyczące wielkości liter, których użyłem, a więc jest mniej przydatny pod tym względem niż kod dfa.

public static String toDisplayCase(String s) {

    final String ACTIONABLE_DELIMITERS = " '-/"; // these cause the character following
                                                 // to be capitalized
    
    StringBuilder sb = new StringBuilder();
    boolean capNext = true;

    for (char c : s.toCharArray()) {
        c = (capNext)
                ? Character.toUpperCase(c)
                : Character.toLowerCase(c);
        sb.append(c);
        capNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0); // explicit cast not needed
    }
    return sb.toString();
}

WARTOŚCI TESTOWE

ciąg

maRTin o'maLLEY

john wilkes-booth

JESZCZE KOLEJNA STRUNA

WYJŚCIA

Ciąg

Martin O'Malley

John Wilkes-Booth

Jeszcze inna struna

scottb
źródło
nie będzie działać z ligaturami takimi jak lj, których wielką literą jest LJ, ale tytułowym przypadkiem jest Lj. Użyj Character.toTitleCasezamiast tego.
mihi
@mihi: również nie będzie działać z innymi specjalistycznymi regułami, np. nazwiska takie jak McNamara czy MacDonald.
scottb
ale tych przypadków z natury nie da się naprawić. Korzystanie z prawidłową funkcję przypadek konwersji (titlecase ma być używany, aby wykorzystać słowo, a nie wielkie, zgodnie z zasadami Unicode) mogą być wykonane (i jest to łatwe).
mihi
Czy (Czy nie) to również spowodowałoby, że „jej” stało się „Jej”?
allicarn
To prawda. Działa to dobrze na polach nazw, ale, jak zauważyłeś, nie na ogólnej prozie. Nie działałoby to nawet dobrze dla wszystkich nazwisk, w szczególności dla Wolkanów (T'Pau zamiast T'pau).
scottb,
21

Użyj WordUtils.capitalizeFully () z Apache Commons.

WordUtils.capitalizeFully(null)        = null
WordUtils.capitalizeFully("")          = ""
WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
jiehanzheng
źródło
1
Niezłe rozwiązanie! Dzięki! Ale to nie działa w 100% przypadków, ponieważ również wykorzystuje duże litery, np. „A” w tym tytule: „To jest tytuł”. Zobacz english.stackexchange.com/questions/14/… . Czy znasz jakąś bibliotekę, która się tym zajmuje?
Eirik W
10

Możesz użyć apache commons langs w następujący sposób:

WordUtils.capitalizeFully("this is a text to be capitalize")

dokument java można znaleźć tutaj: WordUtils.capitalize W pełni dokument java

a jeśli chcesz usunąć spacje między światami, możesz użyć:

StringUtils.remove(WordUtils.capitalizeFully("this is a text to be capitalize")," ")

można znaleźć dokumentację java dla String StringUtils.remove dokumentację java

mam nadzieję, że to pomoże.

Vegegoku
źródło
5

Jeśli chcesz uzyskać poprawną odpowiedź zgodnie z najnowszym standardem Unicode, użyj icu4j.

UCharacter.toTitleCase(Locale.US, "hello world", null, 0);

Zauważ, że jest to wrażliwe na ustawienia regionalne.

Dokumentacja API

Realizacja

Daniel F.
źródło
Zobacz także nowszą mapę przypadków interfejsu API ICU4J: icu-project.org/apiref/icu4j/com/ibm/icu/text/ ...
sffc
Dostępne również w Android API na poziomie 24: developer.android.com/reference/android/icu/lang/…
sffc
3

Oto kolejne podejście oparte na odpowiedziach @ dfa i @ scottb, które obsługują wszelkie znaki inne niż litery / cyfry:

public final class TitleCase {

    public static String toTitleCase(String input) {

        StringBuilder titleCase = new StringBuilder(input.length());
        boolean nextTitleCase = true;

        for (char c : input.toLowerCase().toCharArray()) {
            if (!Character.isLetterOrDigit(c)) {
                nextTitleCase = true;
            } else if (nextTitleCase) {
                c = Character.toTitleCase(c);
                nextTitleCase = false;
            }
            titleCase.append(c);
        }

        return titleCase.toString();
    }

}

Podane dane wejściowe:

MARY ĘNN O'CONNEŽ-ŠUSLIK

wyjście jest

Mary Ęnn O'Connež-Šuslik

mrts
źródło
2

To jest coś, co napisałem, aby przekonwertować snake_case na lowerCamelCase, ale można je łatwo dostosować w zależności od wymagań

private String convertToLowerCamel(String startingText)
{
    String[] parts = startingText.split("_");
    return parts[0].toLowerCase() + Arrays.stream(parts)
                    .skip(1)
                    .map(part -> part.substring(0, 1).toUpperCase() + part.substring(1).toLowerCase())
                    .collect(Collectors.joining());
}
user1743960
źródło
Twoja odpowiedź działa jak urok, jednak rozwiązanie wydaje się nie obsługiwać sekwencji pojedynczych słów, być może warunek if powinien wystarczyć.
yashgarg1232
1

Wiem, że to jest starszy, ale nie ma prostej odpowiedzi, potrzebowałem tej metody do mojego kodowania, więc dodałem tutaj, prostą w użyciu.

public static String toTitleCase(String input) {
    input = input.toLowerCase();
    char c =  input.charAt(0);
    String s = new String("" + c);
    String f = s.toUpperCase();
    return f + input.substring(1);
}
Manish Bansal
źródło
1

Miałem ten problem i szukałem go, a następnie stworzyłem własną metodę, używając niektórych słów kluczowych w języku Java, wystarczy przekazać zmienną String jako parametr i uzyskać dane wyjściowe jako odpowiednie zatytułowane String.

public class Main
{
  public static void main (String[]args)
  {
    String st = "pARVeEN sISHOsIYA";
    String mainn = getTitleCase (st);
      System.out.println (mainn);
  }


  public static String getTitleCase(String input)
  {
    StringBuilder titleCase = new StringBuilder (input.length());
    boolean hadSpace = false;
    for (char c:input.toCharArray ()){
        if(Character.isSpaceChar(c)){
            hadSpace = true;
            titleCase.append (c);
            continue;
        }
        if(hadSpace){
            hadSpace = false;
            c = Character.toUpperCase(c);
            titleCase.append (c);
        }else{
            c = Character.toLowerCase(c);
            titleCase.append (c);
        }
    }
    String temp=titleCase.toString ();
    StringBuilder titleCase1 = new StringBuilder (temp.length ());
    int num=1;
    for (char c:temp.toCharArray ())
        {   if(num==1)
            c = Character.toUpperCase(c);
            titleCase1.append (c);
            num=0;
        }
        return titleCase1.toString ();
    }
}
Parveen Sishodiya
źródło
Tutaj nigdzie nie użyłem metody przycinania, ponieważ w moim przypadku otrzymywałem odpowiednio przycięty ciąg.
Parveen Sishodiya
0

możesz bardzo dobrze używać

org.apache.commons.lang.WordUtils

lub

CaseFormat

z Google API.

gkarthiks
źródło
1
Przydałoby się dodać metodę i przykład.
jechaviz
CaseFormat ma tylko formaty zwykle używane w identyfikatorach programów (UpperCamel, małe myślniki, UPPER_UNDERSCORE itp.) I obsługuje tylko tekst ASCII. Nie działałby dobrze w przypadku konwersji na wielkość liter.
M. Justin,
0

Niedawno napotkałem ten problem i niestety miałem wiele przypadków nazw zaczynających się od Mc i Mac, skończyło się na tym, że użyłem wersji kodu Scotta, którą zmieniłem, aby obsługiwać te prefiksy, więc jest tutaj na wypadek, gdyby ktoś chciał go użyć.

Wciąż istnieją skrajne przypadki, w których to pomija, ale najgorszą rzeczą, jaka może się zdarzyć, jest to, że litera będzie pisana małymi literami, gdy powinna być wielka.

/**
 * Get a nicely formatted representation of the name. 
 * Don't send this the whole name at once, instead send it the components.<br>
 * For example: andrew macnamara would be returned as:<br>
 * Andrew Macnamara if processed as a single string<br>
 * Andrew MacNamara if processed as 2 strings.
 * @param name
 * @return correctly formatted name
 */
public static String getNameTitleCase (String name) {
    final String ACTIONABLE_DELIMITERS = " '-/";
    StringBuilder sb = new StringBuilder();
    if (name !=null && !name.isEmpty()){                
        boolean capitaliseNext = true;
        for (char c : name.toCharArray()) {
            c = (capitaliseNext)?Character.toUpperCase(c):Character.toLowerCase(c);
            sb.append(c);
            capitaliseNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0);
        }                       
        name = sb.toString();    
        if (name.startsWith("Mc") && name.length() > 2 ) {
            char c = name.charAt(2);
            if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
                sb = new StringBuilder();
                sb.append (name.substring(0,2));
                sb.append (name.substring(2,3).toUpperCase());
                sb.append (name.substring(3));
                name=sb.toString();
            }               
        } else if (name.startsWith("Mac") && name.length() > 3) {
            char c = name.charAt(3);
            if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
                sb = new StringBuilder();
                sb.append (name.substring(0,3));
                sb.append (name.substring(3,4).toUpperCase());
                sb.append (name.substring(4));
                name=sb.toString();
            }
        }
    }
    return name;    
}
stary Nick
źródło
0

Konwersja na właściwą wielkość liter:

String s= "ThiS iS SomE Text";
String[] arr = s.split(" ");
s = "";
for (String s1 : arr) {
    s += WordUtils.capitalize(s1.toLowerCase()) + " ";
}
s = s.substring(0, s.length() - 1);

Wynik: „To jest jakiś tekst”

VAIBHAV SHEERSH
źródło
0

Korzystanie z Springa StringUtils:

org.springframework.util.StringUtils.capitalize(someText);

Jeśli i tak już używasz Springa, pozwala to uniknąć wprowadzania innego frameworka.

David Lavender
źródło
0

Użyj tej metody, aby przekonwertować ciąg na wielkość liter:

static String toTitleCase(String word) {
    return Stream.of(word.split(" "))
            .map(w -> w.toUpperCase().charAt(0)+ w.toLowerCase().substring(1))
            .reduce((s, s2) -> s + " " + s2).orElse("");
}
Abdulhamid Yusuf
źródło
0

Ten konwerter przekształca dowolny ciąg zawierający wielkość liter wielbłąda, spacje, cyfry i inne znaki na oczyszczoną wielkość liter.

/**
 * Convert a string to title case in java (with tests).
 *
 * @author Sudipto Chandra
 */
public abstract class TitleCase {

    /**
     * Returns the character type. <br>
     * <br>
     * Digit = 2 <br>
     * Lower case alphabet = 0 <br>
     * Uppercase case alphabet = 1 <br>
     * All else = -1.
     *
     * @param ch
     * @return
     */
    private static int getCharType(char ch) {
        if (Character.isLowerCase(ch)) {
            return 0;
        } else if (Character.isUpperCase(ch)) {
            return 1;
        } else if (Character.isDigit(ch)) {
            return 2;
        }
        return -1;
    }

    /**
     * Converts any given string in camel or snake case to title case.
     * <br>
     * It uses the method getCharType and ignore any character that falls in
     * negative character type category. It separates two alphabets of not-equal
     * cases with a space. It accepts numbers and append it to the currently
     * running group, and puts a space at the end.
     * <br>
     * If the result is empty after the operations, original string is returned.
     *
     * @param text the text to be converted.
     * @return a title cased string
     */
    public static String titleCase(String text) {
        if (text == null || text.length() == 0) {
            return text;
        }

        char[] str = text.toCharArray();
        StringBuilder sb = new StringBuilder();

        boolean capRepeated = false;
        for (int i = 0, prev = -1, next; i < str.length; ++i, prev = next) {
            next = getCharType(str[i]);
            // trace consecutive capital cases
            if (prev == 1 && next == 1) {
                capRepeated = true;
            } else if (next != 0) {
                capRepeated = false;
            }
            // next is ignorable
            if (next == -1) {
                // System.out.printf("case 0, %d %d %s\n", prev, next, sb.toString());
                continue; // does not append anything
            }
            // prev and next are of same type
            if (prev == next) {
                sb.append(str[i]);
                // System.out.printf("case 1, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is not an alphabet
            if (next == 2) {
                sb.append(str[i]);
                // System.out.printf("case 2, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is an alphabet, prev was not +
            // next is uppercase and prev was lowercase
            if (prev == -1 || prev == 2 || prev == 0) {
                if (sb.length() != 0) {
                    sb.append(' ');
                }
                sb.append(Character.toUpperCase(str[i]));
                // System.out.printf("case 3, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is lowercase and prev was uppercase
            if (prev == 1) {
                if (capRepeated) {
                    sb.insert(sb.length() - 1, ' ');
                    capRepeated = false;
                }
                sb.append(str[i]);
                // System.out.printf("case 4, %d %d %s\n", prev, next, sb.toString());
            }
        }
        String output = sb.toString().trim();
        output = (output.length() == 0) ? text : output;
        //return output;

        // Capitalize all words (Optional)
        String[] result = output.split(" ");
        for (int i = 0; i < result.length; ++i) {
            result[i] = result[i].charAt(0) + result[i].substring(1).toLowerCase();
        }
        output = String.join(" ", result);
        return output;
    }

    /**
     * Test method for the titleCase() function.
     */
    public static void testTitleCase() {
        System.out.println("--------------- Title Case Tests --------------------");
        String[][] samples = {
            {null, null},
            {"", ""},
            {"a", "A"},
            {"aa", "Aa"},
            {"aaa", "Aaa"},
            {"aC", "A C"},
            {"AC", "Ac"},
            {"aCa", "A Ca"},
            {"ACa", "A Ca"},
            {"aCamel", "A Camel"},
            {"anCamel", "An Camel"},
            {"CamelCase", "Camel Case"},
            {"camelCase", "Camel Case"},
            {"snake_case", "Snake Case"},
            {"toCamelCaseString", "To Camel Case String"},
            {"toCAMELCase", "To Camel Case"},
            {"_under_the_scoreCamelWith_", "Under The Score Camel With"},
            {"ABDTest", "Abd Test"},
            {"title123Case", "Title123 Case"},
            {"expect11", "Expect11"},
            {"all0verMe3", "All0 Ver Me3"},
            {"___", "___"},
            {"__a__", "A"},
            {"_A_b_c____aa", "A B C Aa"},
            {"_get$It132done", "Get It132 Done"},
            {"_122_", "122"},
            {"_no112", "No112"},
            {"Case-13title", "Case13 Title"},
            {"-no-allow-", "No Allow"},
            {"_paren-_-allow--not!", "Paren Allow Not"},
            {"Other.Allow.--False?", "Other Allow False"},
            {"$39$ldl%LK3$lk_389$klnsl-32489  3 42034 ", "39 Ldl Lk3 Lk389 Klnsl32489342034"},
            {"tHis will BE MY EXAMple", "T His Will Be My Exa Mple"},
            {"stripEvery.damn-paren- -_now", "Strip Every Damn Paren Now"},
            {"getMe", "Get Me"},
            {"whatSthePoint", "What Sthe Point"},
            {"n0pe_aLoud", "N0 Pe A Loud"},
            {"canHave SpacesThere", "Can Have Spaces There"},
            {"  why_underScore exists  ", "Why Under Score Exists"},
            {"small-to-be-seen", "Small To Be Seen"},
            {"toCAMELCase", "To Camel Case"},
            {"_under_the_scoreCamelWith_", "Under The Score Camel With"},
            {"last one onTheList", "Last One On The List"}
        };
        int pass = 0;
        for (String[] inp : samples) {
            String out = titleCase(inp[0]);
            //String out = WordUtils.capitalizeFully(inp[0]);
            System.out.printf("TEST '%s'\nWANTS '%s'\nFOUND '%s'\n", inp[0], inp[1], out);
            boolean passed = (out == null ? inp[1] == null : out.equals(inp[1]));
            pass += passed ? 1 : 0;
            System.out.println(passed ? "-- PASS --" : "!! FAIL !!");
            System.out.println();
        }
        System.out.printf("\n%d Passed, %d Failed.\n", pass, samples.length - pass);
    }

    public static void main(String[] args) {
        // run tests
        testTitleCase();
    }
}

Oto kilka danych wejściowych:

aCamel
TitleCase
snake_case
fromCamelCASEString
ABCTest
expect11
_paren-_-allow--not!
  why_underScore   exists  
last one onTheList 

I moje wyniki:

A Camel
Title Case
Snake Case
From Camel Case String
Abc Test
Expect11
Paren Allow Not
Why Under Score Exists
Last One On The List
Dipu
źródło
0

Wygląda na to, że żadna z odpowiedzi nie formatuje tego w rzeczywistym przypadku tytułowym: „How to Land Your Dream Job”, „To Kill a Mockingbird”, itp., Więc stworzyłem własną metodę. Działa najlepiej w przypadku tekstów w języku angielskim.

private final static Set<Character> TITLE_CASE_DELIMITERS = new HashSet<>();

  static {
    TITLE_CASE_DELIMITERS.add(' ');
    TITLE_CASE_DELIMITERS.add('.');
    TITLE_CASE_DELIMITERS.add(',');
    TITLE_CASE_DELIMITERS.add(';');
    TITLE_CASE_DELIMITERS.add('/');
    TITLE_CASE_DELIMITERS.add('-');
    TITLE_CASE_DELIMITERS.add('(');
    TITLE_CASE_DELIMITERS.add(')');
  }

  private final static Set<String> TITLE_SMALLCASED_WORDS = new HashSet<>();

  static {
    TITLE_SMALLCASED_WORDS.add("a");
    TITLE_SMALLCASED_WORDS.add("an");
    TITLE_SMALLCASED_WORDS.add("the");
    TITLE_SMALLCASED_WORDS.add("for");
    TITLE_SMALLCASED_WORDS.add("in");
    TITLE_SMALLCASED_WORDS.add("on");
    TITLE_SMALLCASED_WORDS.add("of");
    TITLE_SMALLCASED_WORDS.add("and");
    TITLE_SMALLCASED_WORDS.add("but");
    TITLE_SMALLCASED_WORDS.add("or");
    TITLE_SMALLCASED_WORDS.add("nor");
    TITLE_SMALLCASED_WORDS.add("to");
  }

  public static String toCapitalizedWord(String oneWord) {
    if (oneWord.length() < 1) {
      return oneWord.toUpperCase();
    }
    return "" + Character.toTitleCase(oneWord.charAt(0)) + oneWord.substring(1).toLowerCase();
  }

  public static String toTitledWord(String oneWord) {
    if (TITLE_SMALLCASED_WORDS.contains(oneWord.toLowerCase())) {
      return oneWord.toLowerCase();
    }
    return toCapitalizedWord(oneWord);
  }

  public static String toTitleCase(String str) {
    StringBuilder result = new StringBuilder();
    StringBuilder oneWord = new StringBuilder();

    char previousDelimiter = 'x';
    /* on start, always move to upper case */
    for (char c : str.toCharArray()) {
      if (TITLE_CASE_DELIMITERS.contains(c)) {
        if (previousDelimiter == '-' || previousDelimiter == 'x') {
          result.append(toCapitalizedWord(oneWord.toString()));
        } else {
          result.append(toTitledWord(oneWord.toString()));
        }
        oneWord.setLength(0);
        result.append(c);
        previousDelimiter = c;
      } else {
        oneWord.append(c);
      }
    }
    if (previousDelimiter == '-' || previousDelimiter == 'x') {
      result.append(toCapitalizedWord(oneWord.toString()));
    } else {
      result.append(toTitledWord(oneWord.toString()));
    }
    return result.toString();
  }

  public static void main(String[] args) {
    System.out.println(toTitleCase("one year in paris"));
    System.out.println(toTitleCase("How to Land Your Dream Job"));
  }
Mladen Adamovic
źródło
0

To najprostsze rozwiązanie

    static void title(String a,String b){
    String ra = Character.toString(Character.toUpperCase(a.charAt(0)));
    String rb = Character.toString(Character.toUpperCase(b.charAt(0)));
    for(int i=1;i<a.length();i++){
        ra+=a.charAt(i);
    }
    for(int i=1;i<b.length();i++){
        rb+=b.charAt(i);
    }
    System.out.println(ra+" "+rb);
Reppin Frost
źródło
-1

To powinno działać:

String str="i like pancakes";
String arr[]=str.split(" ");
String strNew="";
for(String str1:arr)
{
    Character oldchar=str1.charAt(0);
    Character newchar=Character.toUpperCase(str1.charAt(0));
    strNew=strNew+str1.replace(oldchar,newchar)+" ";    
}
System.out.println(strNew);
Neha
źródło
1
To nie jest poprawna odpowiedź, ponieważ OP poprosił o wbudowaną funkcję. Zobacz także komentarz, który odnosi się do ukrytej złożoności tego problemu, tj. I18n.
Marcus
-2

Najprostszym sposobem przekształcenia dowolnego ciągu znaków w wielkość liter tytułu jest użycie pakietu googles org.apache.commons.lang.WordUtils

System.out.println(WordUtils.capitalizeFully("tHis will BE MY EXAMple"));

Spowoduje to

To będzie mój przykład

Nie jestem pewien, dlaczego nazywa się to „capitalizeFully”, gdzie w rzeczywistości funkcja nie generuje pełnego wyniku kapitałowego, ale tak czy inaczej jest to narzędzie, którego potrzebujemy.

JoeG
źródło
1
Został nazwany, capitalizeFullyponieważ wszystkie słowa są pisane wielką literą, łącznie z tymi, które powinny być pisane małymi literami w tytule. grammar.about.com/od/tz/g/Title-Case.htm
aij
2
Apache Commons nie jest własnością Google. Jest utrzymywany przez Apache Software Foundation. commons.apache.org
ATutorMe
-3

Przepraszam, że jestem początkującym, więc mój nawyk programowania jest do niczego!

public class TitleCase {

    String title(String sent)
    {   
        sent =sent.trim();
        sent = sent.toLowerCase();
        String[] str1=new String[sent.length()];
        for(int k=0;k<=str1.length-1;k++){
            str1[k]=sent.charAt(k)+"";
    }

        for(int i=0;i<=sent.length()-1;i++){
            if(i==0){
                String s= sent.charAt(i)+"";
                str1[i]=s.toUpperCase();
                }
            if(str1[i].equals(" ")){
                String s= sent.charAt(i+1)+"";
                str1[i+1]=s.toUpperCase();
                }

            System.out.print(str1[i]);
            }

        return "";
        }

    public static void main(String[] args) {
        TitleCase a = new TitleCase();
        System.out.println(a.title("   enter your Statement!"));
    }
}
Vishwanath Dasa
źródło