Wie konvertiere ich CamelCase in menschenlesbare Namen in Java?

Ich würde gerne schreiben, eine Methode, die konvertiert CamelCase in einer für Menschen lesbaren Namen.

Hier ist der test-Fall:

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

Kommentar zu dem Problem - Öffnen

Erste, Sie müssen angeben, dass die Regeln der Konvertierung. Zum Beispiel, wie funktioniert PDFLoader werden Sie PDF-Loader? Kommentarautor: Jørn Schou-Rode

Hehe 😀 die Frage ist so vage wie bereits von Jörg Schou-Rode Kommentarautor: RubyDubee

Ich nenne das format "PascalCase". In "camelCase", der erste Buchstabe sollte in Kleinbuchstaben geschrieben sein. Zumindest für die Entwickler, die betroffen sind. msdn.microsoft.com/en-us/library/x2dbyw72(v=vs. 71).aspx Kommentarautor: Muhd

InformationsquelleAutor der Frage Frederik | 2010-04-01

300

Diese Werke mit Ihrem testcases:

static String splitCamelCase(String s) {
   return s.replaceAll(
      String.format("%s|%s|%s",
         "(?<=[A-Z])(?=[A-Z][a-z])",
         "(?<=[^A-Z])(?=[A-Z])",
         "(?<=[A-Za-z])(?=[^A-Za-z])"
      ),
      " "
   );
}

Hier ist ein test-harness:

    String[] tests = {
        "lowercase",        //[lowercase]
        "Class",            //[Class]
        "MyClass",          //[My Class]
        "HTML",             //[HTML]
        "PDFLoader",        //[PDF Loader]
        "AString",          //[A String]
        "SimpleXMLParser",  //[Simple XML Parser]
        "GL11Version",      //[GL 11 Version]
        "99Bottles",        //[99 Bottles]
        "May5",             //[May 5]
        "BFG9000",          //[BFG 9000]
    };
    for (String test : tests) {
        System.out.println("[" + splitCamelCase(test) + "]");
    }

Es nutzt zero-length-matching mit regex lookbehind und lookforward zu finden, wo Sie Leerzeichen einfügen. Grundsätzlich gibt es 3 Muster, und ich benutze String.format setzen Sie Sie zusammen, um Sie lesbarer zu machen.

Die drei Muster sind:

UC hinter mir, UC, gefolgt von LC vor mir

  XMLParser   AString    PDFLoader
    /\        /\           /\

UC nicht hinter mir, UC vor mir

 MyClass   99Bottles
  /\        /\

Brief hinter mir, nicht-Brief vor mir

 GL11    May5    BFG9000
  /\       /\      /\

Referenzen

regular-expressions.info/Lookarounds

Fragen

Unter Verwendung von null-Länge passende lookarounds aufteilen:

InformationsquelleAutor der Antwort polygenelubricants

Kann man es mit org.apache.commons.lang.StringUtils

StringUtils.join(
     StringUtils.splitByCharacterTypeCamelCase("ExampleTest"),
     ' '
);

InformationsquelleAutor der Antwort Ralph

9

Wenn Sie nicht wie "kompliziert" regex ist, und überhaupt nicht die Mühe gemacht um Effizienz geht, dann habe ich dieses Beispiel, um den gleichen Effekt erzielen, in drei Stufen.
```
String name = 
    camelName.replaceAll("([A-Z][a-z]+)", " $1") //Words beginning with UC
             .replaceAll("([A-Z][A-Z]+)", " $1") //"Words" of only UC
             .replaceAll("([^A-Za-z ]+)", " $1") //"Words" of non-letters
             .trim();
```
Geht es alle test-Fälle vor, einschließlich derjenigen, die mit Ziffern.

Wie gesagt, dies ist nicht so gut wie mit dem regulären Ausdruck in einigen anderen Beispielen hier - aber es könnte jemand gut finden es nützlich.

InformationsquelleAutor der Antwort jlb83
6

Können Sie org.modeshape.common.text.Beugung.

Speziell:
```
String humanize(String lowerCaseAndUnderscoredWords,
    String... removableTokens) 
```
Großschreibung des ersten Wortes und stellt die Unterstriche in Leerzeichen und-strips trailing "_id" und der mitgelieferten herausnehmbaren Jetons.
Maven-Artefakt ist: org.modeshape:modeshape-common:2.3.0.Letzte

auf JBoss-repository: https://repository.jboss.org/nexus/content/repositories/releases

Hier ist die JAR-Datei: https://repository.jboss.org/nexus/content/repositories/releases/org/modeshape/modeshape-common/2.3.0.Final/modeshape-common-2.3.0.Final.jar

InformationsquelleAutor der Antwort Hendy Irawan

Die saubere und kürzere Lösung :

StringUtils.capitalize(StringUtils.join(StringUtils.splitByCharacterTypeCamelCase("yourCamelCaseText"), StringUtils.SPACE)); //Your Camel Case Text

InformationsquelleAutor der Antwort Sahil Chhabra

1

Folgende Regex kann verwendet werden, um zu identifizieren, die Kapitelle im inneren Worte:
```
"((?<=[a-z0-9])[A-Z]|(?<=[a-zA-Z])[0-9]]|(?<=[A-Z])[A-Z](?=[a-z]))"
```
Es passt zu jedem Großbuchstaben, dass ist äther nach einer nicht-Großbuchstaben, Ziffern oder gefolgt von einem Kleinbuchstaben und jede Ziffer nach einem Buchstaben.

Wie um ein Leerzeichen einzufügen, bevor Sie geht über meine Java-skills =)

Bearbeitet, gehören die Ziffernschreibweise und die PDF-Loader Fall.

InformationsquelleAutor der Antwort Jens
1

Ich denke, dass Sie zum Durchlaufen der Schnur und erkennen von änderungen von klein-in Großbuchstaben, Großbuchstaben, Kleinbuchstaben, alphabetisch, numerisch, numerisch, alphabetisch. Bei jeder änderung, die Sie erkennen stecken Sie einen Raum mit einer Ausnahme allerdings: auf einen Wechsel von groß - zu Kleinbuchstaben fügen Sie das Leerzeichen ein Zeichen vor.

InformationsquelleAutor der Antwort Felix

Funktioniert .NET... zu optimieren nach Ihren wünschen. Ich habe Kommentare Hinzugefügt, so dass Sie verstehen, was jedes Stück zu tun. (RegEx sein kann, schwer zu verstehen)

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

InformationsquelleAutor der Antwort Xinbi

Für das Protokoll, hier ist ein fast (*) kompatibel 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 verwendet werden, direkt aus Java, wenn der entsprechende scala-library.jar ist in den classpath.

(*) es fällt für die Eingabe "GL11Version" für die, die es gibt "G L11 Version".

InformationsquelleAutor der Antwort gerferra

Nahm ich die Regex aus polygenelubricants und verwandelte Sie in eine extension-Methode auf Objekte:

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

Diese dreht sich alles in einem lesbaren Satz. Es hat eine ToString-Methode auf das übergebene Objekt. Dann wird die Regex gegeben durch polygenelubricants zu split die Zeichenfolge. Dann ist es ToLowers jedes Wort, außer das erste Wort und alle Akronyme. Dachte, es könnte nützlich sein, für jemanden da draußen.

InformationsquelleAutor der Antwort vbullinger

-1

Ich bin kein regex-ninja, also ich würd Durchlaufen der Schnur, halten die Indizes der aktuellen position geprüft & die Vorherige position. Wenn die aktuelle position ein Buchstabe ist, würde ich ein Leerzeichen einfügen, nachdem die Vorherige position und einer Schrittweite von jedem index.

InformationsquelleAutor der Antwort Joel
-2

RegEx funktionieren sollte, so etwas wie ([A-Z]{1}). Dies wird erfassen alle Großbuchstaben, danach könnten Sie ersetzen Sie Sie mit \1 oder wie auch immer Sie sich beziehen können, um RegEx-Gruppen in Java.

InformationsquelleAutor der Antwort Bobby
-3

http://code.google.com/p/inflection-js/

Könnte man die Kette String.Unterstrich().humanize() Methoden nehmen eine CamelCase-string und konvertieren es in eine lesbare Zeichenfolge.

InformationsquelleAutor der Antwort BeesonBison

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.