173 Stimmen

Was ist der einfachste Weg, um einen Java-String von Großbuchstaben (Wörter durch Unterstriche getrennt) in CamelCase (ohne Worttrennzeichen) umzuwandeln?

Der Titel sagt im Grunde alles aus. Wie kann ich in Java auf einfachste / eleganteste Weise einen String im Format "THIS_IS_AN_EXAMPLE_STRING" in das Format "ThisIsAnExampleString" umwandeln? Ich denke, es muss mindestens eine Möglichkeit geben, dies mit String.replaceAll() und einem Regex zu tun.

Meine ersten Gedanken sind: Den String mit einem Unterstrich (_) versehen, den gesamten String in Kleinbuchstaben umwandeln und dann replaceAll verwenden, um jedes Zeichen, das von einem Unterstrich gefolgt wird, in seine Großschreibungsform umzuwandeln.

2voto

Srisa Punkte 959
public String withChars(String inputa) {
    String input = inputa.toLowerCase();
    StringBuilder sb = new StringBuilder();
    final char delim = '_';
    char value;
    boolean capitalize = false;
    for (int i=0; i

`Zeiten: in Millisekunden.

Iterationen = 1000
WithChars: start = 1379685214671 end = 1379685214683 diff = 12
WithRegex: start = 1379685214683 end = 1379685214712 diff = 29

Iterationen = 1000
WithChars: start = 1379685217033 end = 1379685217045 diff = 12
WithRegex: start = 1379685217045 end = 1379685217077 diff = 32

Iterationen = 1000
WithChars: start = 1379685218643 end = 1379685218654 diff = 11
WithRegex: start = 1379685218655 end = 1379685218684 diff = 29

Iterationen = 1000000
WithChars: start = 1379685232767 end = 1379685232968 diff = 201
WithRegex: start = 1379685232968 end = 1379685233649 diff = 681

Iterationen = 1000000
WithChars: start = 1379685237220 end = 1379685237419 diff = 199
WithRegex: start = 1379685237419 end = 1379685238088 diff = 669

Iterationen = 1000000
WithChars: start = 1379685239690 end = 1379685239889 diff = 199
WithRegex: start = 1379685239890 end = 1379685240585 diff = 695

Iterationen = 1000000000
WithChars: start = 1379685267523 end = 1379685397604 diff = 130081
WithRegex: start = 1379685397605 end = 1379685850582 diff = 452977`

1voto

Vanya Usalko Punkte 316

Entschuldigung für meinen Senf, ich denke in Java sind zu viele Wörter)) Ich frage mich nur. Warum ist der Reguläre Ausdruck-Mechanismus in Java nicht so vertraut mit Lambdas wie in JS((

Wie auch immer. Mit Java 8+ kommt mir folgende Konstruktion in den Sinn:

Arrays.stream("THIS_IS_AN_EXAMPLE_STRING".split("_"))
    .collect(StringBuilder::new,
        (result, w) -> result
            .append(w.substring(0, 1).toUpperCase())
            .append(w.substring(1).toLowerCase()),
        StringBuilder::append)
    .toString())

Wenn Sie sich um den Speicherverbrauch kümmern, kümmert sich der folgende Code darum:

"THIS_IS_AN_EXAMPLE_STRING".chars().collect(StringBuilder::new,
    (result, c) -> {
        // Ort zum Bearbeiten erkennen
        if (result.length() > 0 && result.charAt(result.length() - 1) == '_') {
            result.setCharAt(result.length() - 1,
                    Character.toUpperCase((char) c));
        } else if (result.length() > 0) {
            result.append(Character.toLowerCase((char) c));
        } else {
            result.append(Character.toUpperCase((char) c));
        }
    }, StringBuilder::append).toString()

1voto

RoWi Punkte 29
public static String toCamelCase(String value) {
    value = value.replace("_", " ");
    String[] parts = value.split(" ");
    int i = 0;
    String camelCaseString = "";
    for (String part : parts) {
        if (part != null && !part.isEmpty()) {
            if (i == 0) {
                camelCaseString = part.toLowerCase();
            } else if (i > 0 && part.length() > 1) {
                String oldFirstChar = part.substring(0, 1);
                camelCaseString = camelCaseString + part.replaceFirst(oldFirstChar, oldFirstChar.toUpperCase());
            } else {
                camelCaseString = camelCaseString + part + " ";
            }
            i++;
        }
    }
    return camelCaseString;
}

public static void main(String[] args) {
    String string = "HI_tHiS_is_SomE Statement";
    System.out.println(toCamelCase(string));
}

1voto

XORG_99 Punkte 178
public String CamelCase(String str)
{
    String CamelCase="";
    String parts[] = str.split("_");
    for(String part:parts)
    {
        String as=part.toLowerCase();
        int a=as.length();
        CamelCase = CamelCase + as.substring(0, 1).toUpperCase()+ as.substring(1,a);    
    }
    return CamelCase;
}

Dies ist das einfachste Programm, um in CamelCase umzuwandeln. Hoffentlich hilft es Ihnen.

1voto

Muzikant Punkte 7982
geschützter String zuCamelCase(String eingabe) {
    if (eingabe == null) {
        return null;
    }

    if (eingabe.length() == 0) {
        return "";
    }

    // erstes Zeichen in Kleinbuchstaben umwandeln
    String camelCaseStr = eingabe.substring(0, 1).toLowerCase();

    if (eingabe.length() > 1) {
        boolean istWortanfang = false;

        for (int i = 1; i < eingabe.length(); i++) {
            char aktuellesZeichen = eingabe.charAt(i);
            if (aktuellesZeichen == '_') {
                // neues Wort. Unterstriche ignorieren
                istWortanfang = true;
            } else if (Character.isUpperCase(aktuellesZeichen)) {
                // Großbuchstabe. Bei Wortanfang beibehalten
                if (istWortanfang) {
                    camelCaseStr += aktuellesZeichen;
                } else {
                    camelCaseStr += Character.toLowerCase(aktuellesZeichen);
                }
                istWortanfang = false;
            } else {
                camelCaseStr += aktuellesZeichen;
                istWortanfang = false;
            }
        }
    }

    return camelCaseStr;
}

CodeJaeger.com

CodeJaeger ist eine Gemeinschaft für Programmierer, die täglich Hilfe erhalten..
Wir haben viele Inhalte, und Sie können auch Ihre eigenen Fragen stellen oder die Fragen anderer Leute lösen.

Powered by:

X