Wie konvertiere ich CamelCase in Java in für Menschen lesbare Namen?

Question

Ich möchte eine Methode schreiben, die CamelCase in einen für Menschen lesbaren Namen umwandelt.

Hier ist der Testfall:

public void testSplitCamelCase() {
    assertEquals("lowercase", splitCamelCase("lowercase"));
    assertEquals("Class", splitCamelCase("Class"));
    assertEquals("My Class", splitCamelCase("MyClass"));
    assertEquals("HTML", splitCamelCase("HTML"));
    assertEquals("PDF Loader", splitCamelCase("PDFLoader"));
    assertEquals("A String", splitCamelCase("AString"));
    assertEquals("Simple XML Parser", splitCamelCase("SimpleXMLParser"));
    assertEquals("GL 11 Version", splitCamelCase("GL11Version"));
}

Answer 1

Die folgende Regex kann verwendet werden, um die Großbuchstaben in Wörtern zu identifizieren:

"((?<=[a-z0-9])[A-Z]|(?<=[a-zA-Z])[0-9]]|(?<=[A-Z])[A-Z](?=[a-z]))"

Er stimmt mit jedem Großbuchstaben überein, der entweder nach einem Nicht-Großbuchstaben oder einer Ziffer steht oder von einem Kleinbuchstaben gefolgt wird, sowie mit jeder Ziffer nach einem Buchstaben.

Wie man ein Leerzeichen davor einfügt, übersteigt meine Java-Kenntnisse =)

Bearbeitet, um die Zifferntasche und die PDF-Loader-Tasche aufzunehmen.

Answer 2

Ich denke, Sie müssen die Zeichenkette durchlaufen und Änderungen von Kleinbuchstaben zu Großbuchstaben, von Großbuchstaben zu Kleinbuchstaben, von Buchstaben zu Ziffern und von Ziffern zu Buchstaben erkennen. Bei jeder Änderung, die Sie erkennen, fügen Sie ein Leerzeichen ein, mit einer Ausnahme: Bei einem Wechsel von Groß- zu Kleinbuchstaben fügen Sie das Leerzeichen ein Zeichen vorher ein.

Answer 3

Dies funktioniert in .NET... optimieren nach Ihren Wünschen. Ich habe Kommentare hinzugefügt, damit Sie verstehen können, was die einzelnen Teile tun. (RegEx kann schwer zu verstehen sein)

public static string SplitCamelCase(string str)
{
    str = Regex.Replace(str, @"([A-Z])([A-Z][a-z])", "$1 $2");  // Capital followed by capital AND a lowercase.
    str = Regex.Replace(str, @"([a-z])([A-Z])", "$1 $2"); // Lowercase followed by a capital.
    str = Regex.Replace(str, @"(\D)(\d)", "$1 $2"); //Letter followed by a number.
    str = Regex.Replace(str, @"(\d)(\D)", "$1 $2"); // Number followed by letter.
    return str;
}

Answer 4

Für das Protokoll, hier ist eine fast (*) kompatible Scala-Version:

  object Str { def unapplySeq(s: String): Option[Seq[Char]] = Some(s) }

  def splitCamelCase(str: String) =
    String.valueOf(
      (str + "A" * 2) sliding (3) flatMap {
        case Str(a, b, c) =>
          (a.isUpper, b.isUpper, c.isUpper) match {
            case (true, false, _) => " " + a
            case (false, true, true) => a + " "
            case _ => String.valueOf(a)
          }
      } toArray
    ).trim

Einmal kompiliert, kann es direkt von Java aus verwendet werden, wenn sich die entsprechende scala-library.jar im Klassenpfad befindet.

(*) scheitert es bei der Eingabe "GL11Version" für die es Folgendes zurückgibt "G L11 Version" .

Answer 5

Ich habe die Regex aus polygenelubricants genommen und sie in eine Erweiterungsmethode für Objekte verwandelt:

    /// <summary>
    /// Turns a given object into a sentence by:
    /// Converting the given object into a <see cref="string"/>.
    /// Adding spaces before each capital letter except for the first letter of the string representation of the given object.
    /// Makes the entire string lower case except for the first word and any acronyms.
    /// </summary>
    /// <param name="original">The object to turn into a proper sentence.</param>
    /// <returns>A string representation of the original object that reads like a real sentence.</returns>
    public static string ToProperSentence(this object original)
    {
        Regex addSpacesAtCapitalLettersRegEx = new Regex(@"(?<=[A-Z])(?=[A-Z][a-z]) | (?<=[^A-Z])(?=[A-Z]) | (?<=[A-Za-z])(?=[^A-Za-z])", RegexOptions.IgnorePatternWhitespace);
        string[] words = addSpacesAtCapitalLettersRegEx.Split(original.ToString());
        if (words.Length > 1)
        {
            List<string> wordsList = new List<string> { words[0] };
            wordsList.AddRange(words.Skip(1).Select(word => word.Equals(word.ToUpper()) ? word : word.ToLower()));
            words = wordsList.ToArray();
        }
        return string.Join(" ", words);
    }

So wird alles zu einem lesbaren Satz. Es macht einen ToString auf das übergebene Objekt. Dann verwendet es die von polygenelubricants angegebene Regex, um die Zeichenkette zu zerlegen. Dann wird jedes Wort mit Ausnahme des ersten Wortes und aller Akronyme durch ToLowers ersetzt. Ich dachte, es könnte für jemanden da draußen nützlich sein.