Jak przekonwertować CamelCase na nazwy czytelne dla człowieka w Javie?

Możesz to zrobić używając org.apache.commons.lang.StringUtils

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

Jeśli nie lubisz "skomplikowanych" wyrażeń regularnych i wcale nie przejmujesz się wydajnością, użyłem tego przykładu, aby osiągnąć ten sam efekt w trzech etapach.

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

Przechodzi wszystkie powyższe przypadki testowe, łącznie z tymi z cyframi.

Jak mówię, nie jest to tak dobre, jak użycie jednego wyrażenia regularnego w innych przykładach tutaj - ale ktoś może uznać to za przydatne.

Możesz użyć org.modeshape.pospolite.tekst.Inflector .

Konkretnie:

String humanize(String lowerCaseAndUnderscoredWords,
    String... removableTokens) 

Pierwszy wyraz jest pisany wielkimi literami, A podkreślniki zamieniają się w spacje i paski kończące " _id " oraz wszelkie dołączone wymienne tokeny.

Artefakt Mavena to: org.modeshape: modeshape-common:2.3.0.Finał

W repozytorium JBoss: https://repository.jboss.org/nexus/content/repositories/releases

Oto plik JAR: https://repository.jboss.org/nexus/content/repositories/releases/org/modeshape/modeshape-common/2.3.0.Final/modeshape-common-2.3.0.Final.jar{[3]

Schludne i krótsze rozwiązanie:

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

Następujące wyrażenia regularne mogą być używane do identyfikacji wielkich liter w słowach:

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

Pasuje do każdej wielkiej litery, czyli eteru po nie-Wielkiej literze lub cyfrze lub po której następuje mała litera i każda cyfra po literze.

Jak wstawić spację przed nimi jest poza moimi umiejętnościami Javy=)

edytowane w celu uwzględnienia przypadku cyfry i przypadku Ładowarki PDF.

Myślę, że będziesz musiał iterować nad łańcuchem znaków i wykryć zmiany z małych liter na Wielkie, wielkie na małe, Alfabetyczne na numeryczne, Numeryczne na Alfabetyczne. Przy każdej zmianie wykrywasz wstawianie spacji z jednym wyjątkiem: przy zmianie z górnej-na małą literę wstawiasz spację jeden znak przed.

To działa w. NET ... Optymalizuj według własnych upodobań. Dodałem komentarze, abyś mógł zrozumieć, co robi każdy kawałek. (RegEx może być trudny do zrozumienia)

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

Dla przypomnienia, oto prawie ( * ) zgodna Wersja Scali:

  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

Po skompilowaniu może być używany bezpośrednio z Javy, jeśli odpowiednia biblioteka scala.jar jest w klasie.

(*) nie powiedzie się dla wejścia "GL11Version", dla którego zwraca "G L11 Version".

Wziąłem Regex z polygenelubricants i przekształciłem go w metodę rozszerzenia na obiektach:

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

To zamienia wszystko w czytelne zdanie. Wykonuje ToString na przekazanym obiekcie. Następnie używa wyrażeń regularnych podanych przez polygenelubricants, aby podzielić łańcuch. Następnie mówi się o każdym słowie z wyjątkiem pierwszego słowa i wszelkich akronimów. Pomyślałem, że może się komuś przydać.

Nie jestem regex ninja, więc chciałbym iterację nad ciągiem, zachowując indeksy bieżącej pozycji jest sprawdzane i poprzedniej pozycji. Jeśli bieżąca pozycja jest wielką literą, wstawiłbym spację po poprzedniej pozycji i przyrost każdego indeksu.

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

Możesz łańcuchować Łańcuch.underscore ().humanize () metody pobierania ciągu CamelCase i przekształcania go w czytelny dla człowieka ciąg znaków.