wake-up-neo.com

String-Konvertierung in Titelkoffer

Gibt es integrierte Methoden, um eine Zeichenfolge als solche in das Title Case-Format zu konvertieren?

86
Raji

Apache Commons StringUtils.capitalize () oder WordUtils.capitalize ()

beispiel: WordUtils.capitalize("i am FINE") = "I Am FINE" aus WordUtils doc

94
aberrant80

in der String-Klasse gibt es keine Capitalize () - oder TitleCase () - Methoden. Sie haben zwei Möglichkeiten: 

 StringUtils.capitalize(null)  = null
 StringUtils.capitalize("")    = ""
 StringUtils.capitalize("cat") = "Cat"
 StringUtils.capitalize("cAt") = "CAt"
 StringUtils.capitalize("'cat'") = "'cat'"
  • (noch eine weitere) statische Hilfsmethode inTitleCase () schreiben

Beispielimplementierung

public static String toTitleCase(String input) {
    StringBuilder titleCase = new StringBuilder();
    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();
}

Testfall

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

ausgänge:

 String 
 Ein weiterer String 
 NOCH EINE ANDERE STRING 
55
dfa

Wenn ich meine Lösung einreichen darf ...

Die folgende Methode basiert auf der von dfa geposteten Methode. Es nimmt die folgende große Änderung vor (die der Lösung entspricht, die ich damals brauchte): Sie zwingt alle Zeichen in der Eingabezeichenfolge in Kleinbuchstaben, sofern nicht unmittelbar ein "umsetzbarer Begrenzer" vorangestellt wird. In diesem Fall wird das Zeichen erzwungen Großbuchstaben.

Eine wesentliche Einschränkung meiner Routine besteht darin, dass davon ausgegangen wird, dass "title case" für alle Gebietsschemas einheitlich definiert ist und durch die gleichen Fallkonventionen dargestellt wird, die ich verwendet habe. Daher ist er in dieser Hinsicht weniger nützlich als der Code von 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();
}

PRÜFWERTE

ein Faden

maRTin O'MALLEY

john Wilkes-Stand

NOCH EIN ANDERER STRING

AUSGÄNGE

Ein Faden

Martin O'Malley

John Wilkes-Booth

Noch ein String

35
scottb

Verwenden Sie WordUtils.capitalizeFully () aus Apache Commons.

WordUtils.capitalizeFully(null)        = null
WordUtils.capitalizeFully("")          = ""
WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
18
jiehanzheng

Sie können Apache commons langs wie folgt verwenden:

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

sie finden das Java-Dokument hier: WordUtils.capitalizeFully Java-Dokument

und wenn Sie die Leerzeichen zwischen den Welten entfernen möchten, können Sie Folgendes verwenden:

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

sie können das Java-Dokument für String StringUtils.remove Java-Dokument finden.

ich hoffe diese Hilfe.

10
Vegegoku

Wenn Sie die richtige Antwort nach dem neuesten Unicode-Standard erhalten möchten, sollten Sie icu4j verwenden.

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

Beachten Sie, dass dieses Gebietsschema empfindlich ist.

API-Dokumentation

Implementierung

5
Daniel F

Dies ist etwas, das ich geschrieben habe, um snake_case in lowerCamelCase zu konvertieren, es könnte jedoch leicht an die Anforderungen angepasst werden

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

Verwenden Sie diese Methode, um eine Zeichenfolge in Groß- und Kleinschreibung umzuwandeln:

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

Ich weiß, dass dies älter ist, aber nicht die einfache Antwort enthält. Ich benötigte diese Methode für meine Codierung. Ich fügte hier hinzu, einfach anzuwenden. 

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);
}
1
Manish Bansal

Hier ist ein weiterer Take, der auf den Antworten von @ dfa und @ scottb basiert und alle nicht-Buchstaben/Ziffern-Zeichen behandelt:

public final class TitleCase {

    public static String toTitleCase(String input) {

        StringBuilder titleCase = new StringBuilder();
        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();
    }

}

Eingegebene Eingabe:

MARY ÄNN O’CONNE®-ŠUSLIK

die Ausgabe ist

Mary Änn O’Connež-Šuslik

1
mrts

Spring's StringUtils verwenden:

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

Wenn Sie Spring bereits verwenden, wird das Einfügen eines anderen Frameworks vermieden.

0
David Lavender

du kannst es sehr gut gebrauchen 

org.Apache.commons.lang.WordUtils

oder 

CaseFormat

von Google API.

0
opensourcegeek

Ich brauchte einen Titelkoffer-Konverter, um eine beliebige Zeichenfolge mit Kamelfall, Leerzeichen, Ziffern und anderen Zeichen zu transformieren. Aber keine der verfügbaren Lösungen funktionierte. Am Ende habe ich einen für mich gebaut. 

/*
 * Copyright (C) 2018 Sudipto Chandra
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
/**
 * 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();
    }
}

Hier sind einige Eingaben:

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

Und meine Ausgaben:

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
0
Dipu

Ich habe kürzlich auch dieses Problem gefunden und hatte leider viele Vorkommen von Namen, die mit Mc und Mac anfingen. Am Ende verwendete ich eine Version von Scottb's Code, die ich geändert habe, um mit diesen Präfixen umzugehen. Es ist hier für den Fall, dass jemand es verwenden möchte. 

Es gibt immer noch Edge-Fälle, bei denen dies fehlt, aber das Schlimmste, was passieren kann, ist, dass ein Buchstabe klein geschrieben wird, wenn er groß geschrieben werden sollte.

/**
 * 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;    
}
0
Old Nick

Umwandlung in den richtigen Titelfall:

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

Ergebnis: "Dies ist etwas Text"

0
VAIBHAV SHEERSH