Page d'accueil>Tutoriel de programmation réseau>Tutoriel Java

Fonctions et applications d'expressions régulières Java

Auteur：Eve Cole Date de mise à jour：2024-11-17 10:12:01

Une expression régulière est une formule qui utilise un certain modèle pour correspondre à un type de chaîne. Une expression régulière se compose de caractères ordinaires et de métacaractères. Les caractères ordinaires comprennent les lettres majuscules et minuscules et les chiffres, tandis que les métacaractères ont des significations particulières. Qu'il s'agisse de la plate-forme .Net ou de la plate-forme Java, la signification exprimée par les expressions régulières est la même. Ci-dessous, nous analysons principalement les fonctions des expressions régulières et. applications spécifiques. J’espère que l’article vous sera utile et est uniquement à titre de référence.
Depuis que jdk1.4 a lancé le package java.util.regex, il nous a fourni une bonne plate-forme d'application d'expressions régulières Java, car les expressions régulières Java sont un système très complexe.
// barre oblique inverse
/t intervalle('/u0009')
/n saut de ligne ("/u000A")
/r Entrée('/u000D')
/d est numériquement équivalent à [0-9]
/D non-numéro équivaut à [^0-9]
/s espaces [/t/n/x0B/f/r]
/S caractère autre qu'un espace [^/t/n/x0B/f/r]
/w caractères individuels [a-zA-Z_0-9]
/W caractères non séparés [^a-zA-Z_0-9]
/f caractère de saut de page
/e Évasion
/b une limite de mot
/B Une limite non-verbale
/G fin du match précédent
^ commence par une restriction
La condition ^java est limitée aux caractères commençant par Java
$ est la fin de la restriction
La condition java$ est limitée à java comme caractère de fin
. La condition restreint tout caractère unique sauf /n.
java.. la condition est limitée à deux caractères après java, sauf la nouvelle ligne
Ajouter des restrictions spécifiques "[]"
La condition [az] est limitée à un caractère compris entre a et z minuscules
La condition [AZ] est limitée à un caractère dans la plage majuscule de A à Z.
La condition [a-zA-Z] est limitée à un caractère compris entre les minuscules de a à z ou les majuscules de A à Z.
[0-9] La condition est limitée à un caractère compris entre 0 et 9 minuscules.
[0-9a-z] La condition est limitée à un caractère compris entre 0 et 9 minuscules ou entre a et z.
[0-9[az]] La condition est limitée à un caractère (intersection) compris entre 0 et 9 minuscules ou entre a et z.
Ajoutez ^ à [], puis ajoutez une autre restriction "[^]"
La condition [^az] est limitée à un caractère compris entre a et z non minuscules.
La condition [^AZ] est limitée à un caractère dans la plage non majuscule de A à Z.
[^a-zA-Z] La condition est limitée à un caractère compris entre a et z non minuscules et entre A et Z majuscules.
[^0-9] La condition est limitée à un caractère compris entre 0 et 9 non minuscules.
[^0-9a-z] La condition est limitée à un caractère compris entre 0 et 9 non minuscules ou entre a et z.
[^0-9[az]] La condition est limitée à un caractère (intersection) compris entre 0 et 9 non minuscules ou entre a et z.
Lorsque la condition de restriction est qu'un caractère spécifique apparaisse plus de 0 fois, vous pouvez utiliser "*"
 J* plus de 0J
.* 0 caractère ou plus
J.* Plus de 0 caractères entre DJ et D
Lorsque la condition de restriction est qu'un caractère spécifique apparaisse plus d'une fois, vous pouvez utiliser "+"
J+ 1 ou plus J
.+ 1 ou plusieurs caractères
J.+1 ou plusieurs caractères entre DJ et D
Lorsque la restriction est qu'un caractère spécifique apparaisse 0 fois ou plus, vous pouvez utiliser "?"
JA ? J ou JA apparaît
Limiter au nombre spécifié d'occurrences consécutives du caractère "{a}"
J{2}JJ
J{3}JJJ
Il y a plus d'un caractère, et "{a,}"
 J{3,} JJJ,JJJJ,JJJJJ,???(J coexiste plus de 3 fois)
Plus de caractères et moins de b caractères "{a,b}"
 J{3,5} JJJ ou JJJJ ou JJJJJ
Choisissez l'un des deux "|"
J|AJ ou A
Java|Bonjour Java ou Bonjour
"()" spécifie un type de combinaison <BR>Par exemple, si j'interroge les données entre <a href></a> dans <a href="index.html/">index</a>, cela peut être écrit comme <a .*href=/".*/">(.+?)</a>
Lorsque vous utilisez la fonction Pattern.compile, vous pouvez ajouter des paramètres qui contrôlent le comportement de correspondance des expressions régulières Java :
Pattern Pattern.compile (String regex, int flag)
La plage de valeurs du drapeau est la suivante :
Pattern.CANON_EQ Une correspondance est considérée si et seulement si la "décomposition canonique" des deux caractères est exactement la même. Par exemple, après avoir utilisé cet indicateur, l'expression "a/u030A" correspondra à "?". Par défaut, « l’équivalence canonique » n’est pas prise en compte.
Modèle.CASE_INSENSITIVE(?i)
Par défaut, la correspondance insensible à la casse ne fonctionne qu'avec le jeu de caractères US-ASCII. Cet indicateur fait correspondre les expressions quelle que soit la casse. Pour effectuer une correspondance sans ambiguïté des caractères Unicode, combinez simplement UNICODE_CASE avec cet indicateur.
Modèle.COMMENTS(?x)
Dans ce mode, les caractères d'espacement dans les expressions régulières Java seront ignorés lors de la correspondance (Remarque du traducteur : il ne fait pas référence à "//s" dans l'expression, mais fait référence aux espaces, tabulations, retours chariot, etc. dans l'expression. ) . Les commentaires commencent par # et continuent jusqu'à la fin de la ligne. Le mode ligne Unix peut être activé via un indicateur intégré.
Modèle.DOTALL(?s)
Dans ce mode, l'expression '.' peut correspondre à n'importe quel caractère, y compris la fin d'une ligne. Par défaut, l'expression '.' ne correspond pas aux terminateurs de ligne.
Modèle.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 correspondent uniquement au début et à la fin de la chaîne.
Modèle.UNICODE_CASE(?u)
Dans ce mode, si vous activez également l'indicateur CASE_INSENSITIVE, il correspondra aux caractères Unicode sans tenir compte de la casse. Par défaut, la correspondance insensible à la casse ne fonctionne qu'avec le jeu de caractères US-ASCII.
Modèle.UNIX_LINES(?d)
Dans ce mode, seul '/n' est considéré comme un saut de ligne et est comparé à '.', '^' et '$'. En mettant de côté les concepts vagues, voici quelques cas simples d'utilisation régulière de Java :
◆Par exemple, lorsque la chaîne contient une validation

Copiez le code comme suit :

//Trouver une chaîne qui commence par Java et se termine par n'importe quoi
Modèle de modèle = Pattern.compile("^Java.*");
Matcher matcher = pattern.matcher("Java n'est pas un humain");
boolean b= matcher.matches(); //Lorsque la condition est remplie, true sera renvoyé, sinon false sera renvoyé
System.out.println(b);

Lors du fractionnement d'une chaîne avec plusieurs conditions
Copiez le code comme suit :

Modèle modèle = Pattern.compile("[, |]+");
String[] strs = pattern.split("Java Hello World Java,Bonjour,,World|Sun");
pour (int i=0;i<strs.length;i++) {
System.out.println(strs[i]);
}

Remplacement de texte (première occurrence du caractère)
Copiez le code comme suit :

Pattern pattern = Pattern.compile("Expression régulière Java");
Matcher matcher = pattern.matcher("Expression régulière Java Hello World, expression régulière Hello World");
//Remplacez les premières données qui correspondent au modèle régulier
System.out.println(matcher.replaceFirst("Java"));

Remplacement de texte (tous)
Copiez le code comme suit :

Pattern pattern = Pattern.compile("Expression régulière Java");
Matcher matcher = pattern.matcher("Expression régulière Java Hello World, expression régulière Hello World");
//Remplacez les premières données qui correspondent au modèle régulier
System.out.println(matcher.replaceAll("Java"));

Remplacement littéral (remplacement de caractères)
Copiez le code comme suit :

Pattern pattern = Pattern.compile("Expression régulière Java");
Matcher matcher = pattern.matcher("Expression régulière Java Hello World, expression régulière Hello World ");
StringBuffer sbr = new StringBuffer();
tandis que (matcher.find()) {
matcher.appendReplacement(sbr, "Java");
}
matcher.appendTail(sbr);
System.out.println(sbr.toString());

Vérifiez s'il s'agit d'une adresse e-mail
Copiez le code comme suit :

String str="[email protected]";
Modèle modèle = Pattern.compile("[//w//.//-]+@([//w//-]+//.)+[//w//-]+",Pattern.CASE_INSENSITIVE );
Matcher matcher = pattern.matcher(str);
System.out.println(matcher.matches());

Supprimer les balises html
Copiez le code comme suit :

Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL);
Matcher matcher = pattern.matcher("<a href=/"index.html/">Page d'accueil</a>");
Chaîne chaîne = matcher.replaceAll("");
System.out.println(string);

Rechercher la chaîne de condition correspondante en HTML
Copiez le code comme suit :

Modèle modèle = Pattern.compile("href=/"(.+?)/"");
Matcher matcher = pattern.matcher("<a href=/"index.html/">Page d'accueil</a>");
si (matcher.find ())
System.out.println(matcher.group(1));
}

◆Intercepter http://adresse <BR>code
Copiez le code comme suit :

//Intercepter l'URL
Modèle de modèle = Pattern.compile("(http://|https://){1}[//w//.//-/:]+");
Matcher matcher = pattern.matcher("dsdsds<http://dsds//gfgffdfd>fdf");
Tampon StringBuffer = new StringBuffer();
tandis que(matcher.find()){
buffer.append(matcher.group());
buffer.append("/r/n");
System.out.println(buffer.toString());
}

◆Remplacer le code <BR> de caractère chinois {} spécifié
Copiez le code comme suit :

String str = "L'historique actuel du développement de Java va de {0} ans à {1} ans";
String[][] object={new String[]{"//{0//}","1995"},new String[]{"//{1//}","2007"}} ;
System.out.println(replace(str,object));
public static String replace (objet String sourceString,Object[]) {
Chaîne temp=sourceString ;
pour(int i=0;i<objet.longueur;i++){
String[] résultat=(String[])objet[i];
Modèle de modèle = Pattern.compile(result[0]);
Matcher matcher = pattern.matcher(temp);
temp=matcher.replaceAll(result[1]);
}
température de retour ;
}

◆Interroger le fichier<BR>code dans le répertoire spécifié en utilisant des conditions régulières
Copiez le code comme suit :

//Utilisé pour mettre en cache la liste des fichiers
fichiers ArrayList privés = new ArrayList();
//Utilisé pour héberger le chemin du fichier
_chemin de chaîne privé ;
//Utilisé pour transporter des formules régulières non fusionnées
chaîne privée _regexp ;
la classe MyFileFilter implémente FileFilter {
/**
* Faire correspondre le nom du fichier
*/
public boolean accept(Fichier fichier) {
essayer {
Modèle de modèle = Pattern.compile(_regexp);
Matcher match = pattern.matcher(file.getName());
return match.matches();
} attraper (Exception e) {
renvoie vrai ;
}
}
}
/**
* Analyser le flux d'entrée
* Entrées @param
*/
FilesAnalyze (chemin de chaîne, expression rationnelle de chaîne){
getFileName(chemin,expexp);
}
/**
* Analyser les noms de fichiers et ajouter des fichiers
* Entrée @param
*/
private void getFileName (chemin de chaîne, expression rationnelle de chaîne) {
//Table des matières
_path=chemin ;
_regexp=expression rationnelle;
Répertoire de fichiers = 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 dehors
*/
impression publique nulle (PrintStream out) {
Éléments de l'itérateur = files.iterator();
while (elements.hasNext()) {
Fichier file=(Fichier) elements.next();
out.println(file.getPath());
}
}
sortie publique static void (chemin de chaîne, expression rationnelle de chaîne) {
FilesAnalyze fileGroup1 = new FilesAnalyze(chemin,regexp);
fileGroup1.print(System.out);
}
public static void main (String[] arguments) {
sortie("C://","[Az|.]*");
}

Les expressions régulières Java ont de nombreuses fonctions. En fait, tant qu'il s'agit de traitement de caractères, il n'y a rien que les expressions régulières ne puissent faire.

Articles connexes