Regex pour convertir CamelCase en camel_case en Java

Je comprends pourquoi la sortie désirée n’est pas donnée pour convertir en utilisant regex une chaîne comme FooBar à Foo_Bar qui donne à la place Foo_Bar_ . J’aurais pu faire quelque chose avec la subssortingng(0, ssortingng.length() - 2) Ssortingng.subssortingng subssortingng(0, ssortingng.length() - 2) ou simplement remplacer le dernier caractère, mais je pense qu’il existe une meilleure solution à un tel scénario.

Voici le code:

 Ssortingng regex = "([AZ][az]+)"; Ssortingng replacement = "$1_"; "CamelCaseToSomethingElse".replaceAll(regex, replacement); /* outputs: Camel_Case_To_Something_Else_ desired output: Camel_Case_To_Something_Else */ 

Question: Vous cherchez une manière plus simple d’obtenir le résultat souhaité?

Voir cette question et CaseFormat de goyave

dans votre cas, quelque chose comme:

 CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, "SomeInput"); 

lier les minuscules et les majuscules en deux groupes, ça va aller

 public class Main { public static void main(Ssortingng args[]) { Ssortingng regex = "([az])([AZ]+)"; Ssortingng replacement = "$1_$2"; System.out.println("CamelCaseToSomethingElse" .replaceAll(regex, replacement) .toLowerCase()); } } 

Vous pouvez utiliser l’extrait de code ci-dessous:

 Ssortingng replaceAll = key.replaceAll("(.)(\\p{Upper})", "$1_$2").toLowerCase(); 

Pourquoi ne pas simplement faire correspondre le caractère précédent avec un début de ligne non?

 Ssortingng text = "CamelCaseToSomethingElse"; System.out.println(text.replaceAll("([^_A-Z])([AZ])", "$1_$2")); 

Notez que cette version est sûre pour être effectuée sur quelque chose qui est déjà camel cased.

Ajoutez une assertion lookahead de largeur zéro.

http://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html

Lisez la documentation pour (?=X) etc.

Personnellement, je diviserais la chaîne, puis la recombinerais. Cela peut même être plus rapide une fois bien fait, et cela rend le code beaucoup plus facile à comprendre que la magie des expressions régulières. Ne vous méprenez pas: j’aime les expressions régulières. Mais ce n’est pas vraiment une expression régulière soignée, et cette transformation n’est pas non plus une tâche d’expression rationnelle classique. Après tout, il semble que vous vouliez aussi faire des minuscules?

Un hack moche mais rapide serait de remplacer (.)([AZ]+) par $1_$2 et ensuite de minuscule toute la chaîne après (sauf si vous pouvez faire des expressions rationnelles de style perl, où vous pouvez minuscule directement le remplacement!). Pourtant, je considère le fractionnement en transition entre le bas et le haut, puis la transformation, puis l’adhésion comme la manière la plus appropriée et la plus lisible de le faire.

 ([AZ][az\d]+)(?=([AZ][az\d]+)) 

Devrait chercher une majuscule suivie de minuscules. Le lookahead positif recherchera un autre mot commençant par une lettre majuscule suivi de lettres minuscules mais ne l’inclura PAS dans la correspondance.

Regardez ici: http://regexr.com?30ooo

 public class ReplaceFromCameltoSnake { public static void main(Ssortingng args[]){ Ssortingng s1=" totalAmountWithoutDiscount"; Ssortingng replaceSsortingng=s1.replaceAll("([AZ]+)","\\_$1").toLowerCase(); System.out.println(replaceSsortingng); } } 

Je ne peux pas fournir RegEx, ce serait incroyablement complexe de toute façon.

Essayez cette fonction avec une reconnaissance automatique des acronymes.

Malheureusement, la librairie Guava ne détecte pas automatiquement les acronymes en majuscules, donc “bigCAT” serait converti en “BIG_C_A_T”

 /** * Convert to UPPER_UNDERSCORE format detecting upper case acronyms */ private Ssortingng upperUnderscoreWithAcronyms(Ssortingng name) { SsortingngBuffer result = new SsortingngBuffer(); boolean begin = true; boolean lastUppercase = false; for( int i=0; i < name.length(); i++ ) { char ch = name.charAt(i); if( Character.isUpperCase(ch) ) { // is start? if( begin ) { result.append(ch); } else { if( lastUppercase ) { // test if end of acronym if( i+1 

J’ai dû l’implémenter pour convertir certaines clés au format camel en minuscules avec des traits de soulignement. L’expression régulière que j’ai trouvée est la suivante:

(?

En anglais, cela signifie lettre majuscule qui n'est pas précédée par le début de la chaîne, un trait de soulignement ou une autre lettre majuscule .

Dans les exemples ci-dessous, le caractère en gras est celui qui doit produire une correspondance en utilisant l'expression régulière susmentionnée:

  • Camel C omte
  • camel c ase s
  • camel_case_to_something_else
  • Camel_Case_To_Something_Else
  • CAMEL_CASE_TO_SOMETHING_ELSE

Notez que l'expression n'affecte pas la chaîne qui est déjà en minuscule + format de soulignement.

Le modèle de remplacement serait:

_l$1

Ce qui signifie en minuscule du premier groupe de saisie , le premier groupe de capture étant la majuscule. Vous pouvez aussi réduire la chaîne entière par la suite pour normaliser les deux derniers échantillons de la liste ci-dessus.