Résumé de l'utilisation des fonctions Remplace, remplacer et remplacer First en Java

Tout d'abord, résumons les usages d'eux trois:

・ Remplacer (cible CharSequence, remplacement de charondence) , remplacer toutes les cibles par le remplacement, les deux paramètres sont des chaînes.

・ RempaceALL (chaîne Regex, remplacement de la chaîne) , remplacez toutes les correspondances regexes par le remplacement. Le regex est évidemment une expression régulière, le remplacement est une chaîne.

・ RemplaceFirst (String Regex, remplacement de la chaîne) , qui est fondamentalement le même que RempacEALL, la différence est que seule la première correspondance est remplacée.

Ensuite, il y a une exigence simple, qui est de remplacer A dans la chaîne source par / a, le code est le suivant:

 System.out.println ("abac" .replace ("a", "// a")); ///ab/acsystem.out.println("abac".replaceall("a "," // a ")); //abacsystem.out.println("abac".replacefirst("a "," // a ")); //abacsystem.out.println("abac".replacefirst("a "," // a ")); // abac

Le résultat a été une grande surprise. Après tant d'années de remplacement, j'étais un peu confus.

La chaîne source est "ABAC", puis nous trouvons "A", le remplace par / a. Puisque / est un personnage de Java Escape, si vous voulez exprimer / a, vous devez écrire "// a", la première barre oblique inverse échappe à la deuxième barre arrière dans une chaîne normale.

Avec trois expressions de remplacement, seul le résultat de la première fonction de remplacement est correct. Quel est le problème?

RempacEALL et RemplaceFirst nécessitent que le premier paramètre soit une expression régulière. "A" peut être compris comme la chaîne A et l'expression régulière A, donc le premier paramètre est bien.

Le problème réside dans le deuxième paramètre. Si les lecteurs lisent soigneusement les commentaires de la fonction de remplacement, ils trouveront l'explication suivante:

 Notez que les barreaux récessifs (/) et les signes en dollars ($) dans la chaîne de remplacement peuvent rendre les résultats différents de celui s'il était traité comme une chaîne de remplacement littérale; Voir Matcher.ReplaceALL. Utilisez java.util.regex.matcher.quotereplacement pour supprimer la signification particulière de ces caractères, si vous le souhaitez.

Étant donné que le premier paramètre de remplacement et de RemplaceFirst est régulier, nous pouvons faire quelques petites astuces dans le deuxième paramètre, comme une exigence: remplacer A dans la chaîne source par le caractère suivant A, le code est le suivant:

 System.out.println ("ABAC" .replaceALL ("A (// W)", "1 $ 1")); //bbccSystem.out.println("abac".replacefirst("a(/w) "," 1 $ 1 ")); // BBAC

Supposons que la signification de la régularité peut être comprise par le lecteur, on peut voir que dans le deuxième paramètre, le symbole $ peut être utilisé pour obtenir le contenu du groupe. Dans cet exemple, 1 $ est utilisé pour obtenir le contenu du premier groupe, c'est-à-dire le personnage suivant immédiatement a.

Par conséquent, le symbole $ a une signification particulière dans le deuxième paramètre, et l'écrire au hasard provoquera une erreur:

 System.out.println ("ABAC" .replaceALL ("a (// w)", "$")); // Exception dans le thread "Main" java.lang.stringindexoutofboundSexception: index de chaîne hors de portée: 1

Et si je veux juste le remplacer par $? Cela nécessite d'échapper aux caractères:

 System.out.println ("ABAC" .replaceALL ("A", "// $")); // $ b $ c

À ce stade, les lecteurs peuvent soudainement réaliser que l'arrière-plan a également une signification particulière (échappée) dans le deuxième paramètre, donc si nous voulons exprimer la barre de bar, nous devons y échapper à nouveau:

 System.out.println ("ABAC" .replaceALL ("A", "/// a")); ///ab/acsystem.out.println("abac".replacefirst("a "," ///// a ")); /// ABAC

Pour comprendre brièvement, la barre arrière avant dans "//// a" échappe à l'arrière-plan par la suite, de sorte que l'arrière-plan est une chaîne normale. De cette façon, la chaîne vue dans la mémoire Java est "// a". Lors du traitement, la fonction de remplacement utilise la barre arrière avant pour échapper à la barre arrière par la suite pour exprimer que la barre arrière est par la suite une chaîne ordinaire, non utilisée pour échapper à $, et la chaîne finale en mémoire est "/ a", afin que A puisse être remplacé avec succès par / a.

Résumer

La question de l'évasion est en effet enchevêtrée. Grâce à cet article, l'auteur espère que les lecteurs pourront rester éveillés lors de l'utilisation de ces fonctions à l'avenir, être conscients des caractères spéciaux dans les paramètres et éviter d'écrire des bombes. Ce qui précède est l'intégralité du contenu de cet article. J'espère que cela sera utile à l'étude et au travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer.