Comme nous le savons tous, dans le développement de programmes, il est inévitable de rencontrer des situations où les cordes doivent être égales, recherchées, remplacées et jugées. Ces situations sont parfois plus compliquées. S'il est résolu dans un codage pur, il gaspillera souvent le temps et l'énergie des programmeurs. Par conséquent, l'apprentissage et l'utilisation d'expressions régulières sont devenus le principal moyen de résoudre cette contradiction.
Comme nous le savons tous, les expressions régulières sont une spécification qui peut être utilisée pour la correspondance et le remplacement des modèles. Une expression régulière est un modèle littéral composé de caractères ordinaires (tels que les caractères A à Z) et des caractères spéciaux (métacharacteurs). Il est utilisé pour décrire une ou plusieurs cordes à égaler lors de la recherche du corps d'un littéral. L'expression régulière agit comme un modèle pour correspondre à un modèle de caractère avec la chaîne recherchée.
Depuis que JDK1.4 a lancé le package java.util.regex, il nous a fourni une bonne plate-forme d'application d'expression régulière Java.
Parce que les expressions régulières sont un système très complexe, je ne donnerai que quelques exemples de concepts d'introduction. Pour plus d'informations, veuillez vous référer aux livres connexes et les explorer vous-même.
// bombardement
/ t Interval ('/ u0009')
/ n Line Break ('/ u000a')
/ r ENTER ('/ u000d')
/ d Le nombre est équivalent à [0-9]
/ D Le non-chiffre équivaut à [^ 0-9]
/ s symbole vierge [/ t / n / x0b / f / r]
/ S symbole non rouge [^ / t / n / x0b / f / r]
/ W Caractère individuel [A-ZA-Z_0-9]
/ W Caractère non individuel [^ A-ZA-Z_0-9]
/ F PARE PAGE
/ e évasion
/ b la limite d'un mot
/ B une limite non mot
/ G fin du match précédent
^ commence par la limite
^ La limite de condition java est aux personnages commençant par Java
$ est la fin de la limite
La limite de condition Java $ est des caractères financiers
. Limite conditionnelle tout caractère unique sauf / n
Java .. Après la limite de condition est Java, deux caractères à l'exception de la nouvelle ligne
Ajouter des restrictions spécifiques "[]"
[AZ] Les conditions sont limitées à un caractère de la gamme minuscule A à Z
[AZ] Les conditions sont limitées à un caractère de la gamme en majuscules A à Z
[A-ZA-Z] Les conditions sont limitées à un caractère dans la gamme minuscule A à Z ou Uppercase A à Z
[0-9] Les conditions sont limitées à un caractère dans la gamme minuscule 0 à 9
[0-9a-z] Les conditions sont limitées aux minuscules 0 à 9 ou A à la gamme Z
[0-9 [AZ]] Les conditions sont limitées aux minuscules 0 à 9 ou A à la gamme Z (intersection)
[] et ajouter la condition de restriction "[^]" encore une fois
[^ az] Les conditions sont limitées à un caractère dans la gamme de non-lavage A à Z
[^ AZ] La condition limite un caractère dans la gamme non-Caps A à Z
[^ a-za-z] Les conditions sont limitées à un caractère dans la gamme de non-lavage A à Z ou en majuscules A à Z
[^ 0-9] Les conditions sont limitées à un caractère dans la gamme de non-LowerCase 0 à 9
[^ 0-9a-z] Les conditions sont limitées à un caractère dans la gamme de non-Lobice 0 à 9 ou A à Z
[^ 0-9 [AZ]] Les conditions sont limitées à un caractère dans la plage de non-laideur 0 à 9 ou A à Z (intersection)
Lorsque la condition de restriction est qu'un caractère spécifique apparaît plus de 0 fois, vous pouvez utiliser "*"
J * plus de 0 J
. * Tout caractère au-dessus de 0
J. * DJ et D TOUT 0 caractères
Lorsque la condition de restriction est qu'un caractère spécifique apparaît plus d'une fois, vous pouvez utiliser "+"
J + 1 ou plus J
. + 1 ou plusieurs caractères arbitraires
J. + 1 ou plus de caractère entre DJ et D
Lorsque la condition de restriction est qu'un caractère spécifique apparaît 0 ou plus de fois, "?" peut être utilisé.
JA? J ou JA apparaît
Limite à l'occurrence continue du caractère numérique spécifié "{a}"
J {2} JJ
J {3} JJJ
Plus qu'un texte, et "{a,}"
J {3,} JJJ, Jjjjj, jjjjj, ??? (J coexiste plus de 3 fois)
Plus d'un texte, moins que b "{a, b}"
J {3,5} JJJ ou Jjjj ou Jjjjj
Prendre l'un des deux
J | aj ou un
Java | Bonjour java ou bonjour
"()" Spécifie un type de combinaison, par exemple, si je demande les données entre <a href = / "index.html /"> index </a>, je peux écrire <a. * href = / ". * /"> (. +?) </a>
Lorsque vous utilisez la fonction Pattern.Compile, vous pouvez ajouter des paramètres qui contrôlent le comportement d'appariement des expressions régulières:
Pattern Pattern.Compile (String Regex, INT Flag)
La plage de valeurs des drapeaux est la suivante:
Pattern.Canon_eq La correspondance est déterminée si et seulement si la "décomposition canonique" des deux caractères est exactement la même. Par exemple, après avoir utilisé ce drapeau, l'expression "a / u030a" correspondra "?". Par défaut, "l'égalité canonique" n'est pas prise en compte.
Pattern.case_insensitive (? I) Par défaut, la correspondance non identifiée de cas est uniquement disponible pour les ensembles de caractères US-ASCII. Cet drapeau permet aux expressions d'ignorer le cas de correspondance. Pour faire correspondre les caractères Unicode avec une taille inconnue, combinez simplement Unicode_Case avec ce drapeau.
Pattern.comments (? X) Dans ce mode, les caractères de l'espace (dans des expressions régulières) seront ignorés lors de la correspondance (note du traducteur: ne se réfère pas à "// s" dans l'expression, mais se réfère aux espaces, aux onglets, au retour du chariot, etc.) dans l'expression. Les commentaires commencent à # et se terminent à cette ligne. Le mode Row Unix peut être activé via des drapeaux intégrés.
Pattern.dotall (? S) Dans ce mode, l'expression '.' peut correspondre à n'importe quel personnage, y compris le caractère final représentant une ligne. Par défaut, l'expression '.' ne correspond pas au caractère final de la ligne.
Motif.Multiline
(? M) Dans ce mode, '^' et '$' correspondent respectivement au début et à la fin d'une ligne. De plus, '^' correspond toujours au début de la chaîne, et '$' correspond également à la fin de la chaîne. Par défaut, ces deux expressions ne correspondent qu'au début et à la fin de la chaîne.
Pattern.Unicode_case
(? U) Dans ce mode, si vous activez également le drapeau Case_insensitive, il correspondra aux caractères Unicode avec un cas non identifié. Par défaut, la correspondance insensible à la cas n'est disponible que pour les jeux de caractères US-ACCII.
Pattern.Unix_lines (? D) Dans ce mode, seul «/ n» est considéré comme une avorter d'une ligne et correspond ».», «^», Et «$».
En mettant de côté le concept vide, voici quelques cas d'utilisation réguliers Java simples:
◆ Par exemple, lorsque la chaîne contient une vérification
// Trouvez une chaîne qui commence par Java et se termine à volonté Pattern = Pattern.Compile ("^ java. *"); Matcher Matcher = Pattern.matcher ("Java n'est pas un humain"); Boolean b = Matcher.matches (); // Lorsque la condition est satisfaite, elle renverra vrai, sinon faux System.out.println (b); ◆ Lors de la division des chaînes avec plusieurs conditions
Pattern Pattern = Pattern..
◆ Remplacement du texte (le caractère apparaît pour la première fois)
Pattern Match = Pattern.Compile ("Expression régulière"); Matcher Matcher = Pattern.matcher ("Expression régulière Hello World, Expression régulière Hello World"); // Remplacez les premières données qui se conforment à la régularité System.out.println (Matcher.replaceFirst ("java")); ◆ Remplacement du texte (tous)
Pattern Match = Pattern.Compile ("Expression régulière"); Matcher Matcher = Pattern.matcher ("Expression régulière Hello World, Expression régulière Hello World"); // Remplacez les premières données qui se conforment à la régularité System.out.println (Matcher.replaceAll ("Java")); ◆ Remplacement du texte (remplacer les caractères)
Pattern Pattern = Pattern.Compile ("Expression régulière"); Matcher Matcher = Pattern.Matcher ("Expression régulière Hello World, Expression régulière Hello World"); StringBuffer SBR = new StringBuffer (); while (Matcher.Find ()) {Matcher.ApendReplacement (SBR, "Java");} Matcher.ApendTail (SBR); System.out.println (SBR.TOSTRING ());◆ Vérifiez s'il s'agit d'une adresse e-mail
String str = "[email protected]"; Pattern Pattern = Pattern.Compile ("[// w //.//-.
◆ Supprimer les balises HTML
Pattern Pattern = Pattern.Compile ("<. +?>", Pattern.Dotall); Matcher Matcher = Pattern.matcher ("<a href = /" index.html / "> home </a>"); String String = Matcher.ReplaceAll (""); System.out.println (String); ◆ Trouvez la chaîne de condition correspondante en HTML
Pattern Pattern = Pattern..
◆ Intercepter http: //
// Intercept urlPattern Pattern = Pattern.Compile ("(http: // | https: //) {1} [//w////-//:] +"); Matcher Matcher = Pattern.matcher ("dsdsds <http: // dsds // gfgffdfd> fdf"); stringbuffer tamper = new StringbUffer (); while (Matcher.Find ()) {buffer.append (Matcher.Group ()); Buffer.APPEND ("/ r / n"); System.out.println (Buffer.ToString ());}◆ Remplacez les caractères chinois spécifiés {}
String str = "L'historique de développement actuel de Java provient de {0} années - {1} années"; String [] [] objet = {nouvelle chaîne [] {"// {0 //}", "1995"}, nouvelle chaîne [] {"// {1 //}", "2007"}}; STRINCE; System.out.println (Remplace Sourcestring, objet [] objet) {String temp = SourCestring; for (int i = 0; i <object.length; i ++) {String [] result = (string []) objet [i]; Motif motif = modèle.compile (résultat [0]); Matcher Matcher = Pattern.matcher (temp); Temp = Matcher.ReplaceALL (résultat [1]); } Retour Temp;}◆ Requête des fichiers dans les répertoires désignés avec des conditions régulières
// Utilisé pour mettre en cache la liste des fichiers privés ArrayList Files = new ArrayList (); // Utilisé pour héberger un chemin de fichier String privé _path; // Utilisé pour héberger une chaîne privée de formule régulière non fusionnée _Regexp; classe MyFileFilter implémente FileFilter {/ ** * Nom du fichier de correspondance * / public boolean accepte (fichier file) {try {motif moderne = motive.compile (_regexp); Matcher Match = Pattern.matcher (file.getName ()); return Match.matches (); } catch (exception e) {return true; }}} / ** * Analyser le flux d'entrée * @Param Entrées * / FilesAnaLyze (String Path, String regexp) {getFileName (path, regexp); } / ** * Analyser le nom de fichier et ajouter des fichiers * @param entrée * / private void getFileName (String path, string regexp) {// Directory_Path = path; _regexp = regexp; File Directory = nouveau fichier (_path); File [] filesFile = Directory.ListFiles (new MyFileFilter ()); if (filesFile == null) return; pour (int j = 0; j <filesFile.length; j ++) {files.add (filesFile [j]); } retour; } / ** * Afficher les informations de sortie * @param out * / public void print (printStream out) {iterator elements = files.iterator (); while (elements.hasnext ()) {fichier file = (file) elements.next (); out.println (file.getPath ()); }} public static void output (String Path, String regexp) {fileSanalyze fileGroup1 = new FileSanalyze (path, regexp); fileGroup1.print (System.out); } public static void main (String [] args) {output ("c: //", "[az |.] *"); }Il existe de nombreuses fonctions de régularité Java. En fait, tant qu'il s'agit du traitement des caractères, il n'y a rien que la régularité ne puisse pas faire. (Bien sûr, il faut beaucoup de temps pour l'expliquer régulièrement ||| ...)
Ce qui précède est l'information triant les expressions régulières de Java. Nous continuerons d'ajouter des informations pertinentes à l'avenir. Merci pour votre soutien à ce site!