Expressions régulières Java

Les expressions régulières définissent des modèles de chaînes.

Les expressions régulières peuvent être utilisées pour rechercher, modifier ou manipuler du texte.

Les expressions régulières ne se limitent pas à une seule langue, mais il existe des différences subtiles dans chaque langue.

Les expressions régulières Java ressemblent le plus à celles de Perl.

Le package java.util.regex comprend principalement les trois classes suivantes :

• Classe de modèle :

  L'objet pattern est une représentation compilée d'une expression régulière. La classe Pattern n’a pas de constructeur public. Pour créer un objet Pattern, vous devez d'abord appeler sa méthode de compilation statique publique, qui renvoie un objet Pattern. Cette méthode accepte une expression régulière comme premier paramètre.

• Classe de correspondance :

  L'objet Matcher est un moteur qui interprète et fait correspondre les chaînes d'entrée. Comme la classe Pattern, Matcher n'a pas de constructeur public. Vous devez appeler la méthode matcher de l'objet Pattern pour obtenir un objet Matcher.

• PatternSyntaxException :

  PatternSyntaxException est une classe d'exceptions non obligatoire qui représente une erreur de syntaxe dans un modèle d'expression régulière.

Groupe de capture

La capture de groupes est un moyen de traiter plusieurs personnages comme une seule unité, créée en regroupant les caractères entre parenthèses.

Par exemple, l'expression régulière (chien) crée un seul groupe contenant "d", "o" et "g".

Les groupes de capture sont numérotés en comptant leurs parenthèses ouvrantes de gauche à droite. Par exemple, dans l’expression ((A)(B(C))), il existe quatre de ces groupes :

• ((ABC)))

• (UN)

• (B(C))

• (C)

Vous pouvez vérifier le nombre de groupes d'une expression en appelant la méthode groupCount de l'objet matcher. La méthode groupCount renvoie une valeur int, indiquant que l'objet matcher possède actuellement plusieurs groupes de capture.

Il existe également un groupe spécial (groupe 0) qui représente toujours l'expression entière. Le groupe n'est pas inclus dans la valeur de retour de groupCount.

Exemple

L'exemple suivant montre comment rechercher une chaîne de chiffres à partir d'une chaîne donnée :

 importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;

RegexMatches de classe publique
{
public static void main (String args[]){

// Recherche la chaîne selon le modèle spécifié String line = "Cette commande a été passée pour QT3000 ! OK ?";
Modèle de chaîne = "(.*)(\d+)(.*)";

//Créer un objet Pattern Pattern r = Pattern.compile(pattern);

// Créez maintenant l'objet matcher Matcher m = r.matcher(line);
si (m.find( )) {
System.out.println("Valeur trouvée : " + m.group(0) );
System.out.println("Valeur trouvée : " + m.group(1) );
System.out.println("Valeur trouvée : " + m.group(2) );
} autre {
System.out.println("AUCUNE CORRESPONDANCE");
}
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 Valeur trouvée : Cette commande a été passée pour QT3000, OK ?
Valeur trouvée : Cette commande a été passée pour QT300
Valeur trouvée : 0

Syntaxe des expressions régulières

Méthodes de la classe Matcher

Méthode d'indexation

La méthode index fournit des valeurs d'index utiles qui indiquent exactement où se trouve la correspondance dans la chaîne d'entrée :

méthodes de recherche

La méthode de recherche examine la chaîne d'entrée et renvoie une valeur booléenne indiquant si le modèle a été trouvé :

méthode de remplacement

La méthode de remplacement est une méthode permettant de remplacer du texte dans la chaîne d'entrée :

méthodes de début et de fin

Voici un exemple de comptage du nombre d'occurrences du mot « chat » dans une chaîne d'entrée :

 importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;

RegexMatches de classe publique
{
chaîne finale statique privée REGEX = "\bcat\b";
chaîne finale statique privée INPUT =
"chat chat chat cattie chat";

public static void main (String args[]){
Modèle p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // Récupère l'objet matcher int count = 0;

while(m.find()) {
compte++;
System.out.println("Numéro correspondant "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 Match numéro 1
début() : 0
fin() : 3
Match numéro 2
début() : 4
fin() : 7
Match numéro 3
début() : 8
fin() : 11
Match numéro 4
début() : 19
fin() : 22

Vous pouvez voir que cet exemple utilise des limites de mots pour garantir que les lettres « c », « a », « t » ne sont pas simplement une sous-chaîne d'un mot plus long. Il fournit également des informations utiles sur l'endroit où la correspondance s'est produite dans la chaîne d'entrée.

La méthode start renvoie l'index initial de la sous-séquence capturée par le groupe donné lors de l'opération de correspondance précédente, et la méthode end en ajoute un à l'index du dernier caractère correspondant.

correspondances et méthodes LookingAt

Les méthodes matches et LookingAt sont toutes deux utilisées pour essayer de faire correspondre un modèle de séquence d'entrée. La différence entre eux est que matches nécessite que la séquence entière corresponde, contrairement à LookingAt.

Ces deux méthodes sont souvent utilisées au début de la chaîne d'entrée.

Nous utilisons l'exemple suivant pour expliquer cette fonction :

 importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;

RegexMatches de classe publique
{
chaîne finale statique privée REGEX = "foo";
chaîne finale statique privée INPUT = "fooooooooooooooooo";
modèle de modèle statique privé ;
Matcher Matcher statique privé ;

public static void main (String args[]){
motif = Modèle.compile(REGEX);
matcher = motif.matcher(INPUT);

System.out.println("Le REGEX actuel est : "+REGEX);
System.out.println("L'ENTRÉE actuelle est : "+INPUT);

System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 La REGEX actuelle est : foo
L'ENTRÉE actuelle est : fooooooooooooooooo
LookingAt() : vrai
matches() : faux

Méthodes replaceFirst et replaceAll

Les méthodes replaceFirst et replaceAll sont utilisées pour remplacer le texte qui correspond à une expression régulière. La différence est que replaceFirst remplace la première correspondance et replaceAll remplace toutes les correspondances.

L'exemple suivant explique cette fonctionnalité :

 importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;

RegexMatches de classe publique
{
chaîne statique privée REGEX = "chien" ;
private static String INPUT = "Le chien dit miaou. " +
"Tous les chiens disent miaou.";
chaîne statique privée REPLACE = "chat" ;

public static void main (String[] arguments) {
Modèle p = Pattern.compile(REGEX);
// récupère un objet matcher
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 Le chat dit miaou. Tous les chats disent miaou.

Méthodes appendReplacement et appendTail

La classe Matcher fournit également les méthodes appendReplacement et appendTail pour le remplacement de texte :

Regardez l'exemple suivant pour expliquer cette fonctionnalité :

 importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;

RegexMatches de classe publique
{
chaîne statique privée REGEX = "a*b" ;
chaîne statique privée INPUT = "aabfooaabfooabfoob" ;
chaîne statique privée REPLACE = "-";
public static void main (String[] arguments) {
Modèle p = Pattern.compile(REGEX);
// Récupère l'objet matcher Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
tandis que(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 -foo-foo-foo-

Méthodes de la classe PatternSyntaxException

PatternSyntaxException est une classe d'exceptions non forcées qui indique une erreur de syntaxe dans un modèle d'expression régulière.

La classe PatternSyntaxException fournit les méthodes suivantes pour nous aider à voir quelles erreurs se sont produites.