[Java] Résumé des expressions régulières

liste

Exemple de correspondance téléphone / code postal

//Exemple de téléphone 1/Correspondance du code postal
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
 public static void main(String[] args) {
    //Chaîne de caractères pour juger
    String str = "012-345-6789";
    //Générer un modèle pour juger
    Pattern p = Pattern.compile("\\d{2,4}-\\d{2,4}-\\d{4}"); //numéro de téléphone
    //Pattern p = Pattern.compile("^\\d{3}-\\d{4}$"); //Code postal
    Matcher m = p.matcher(str);

    System.out.println(m.find()); //true
    }
}

Exemple de correspondance avant / arrière / partielle

//Échantillon 2 avant/Arrière/Match partiel
public class Main {
 public static void main(String[] args) {
    //Chaîne de caractères pour juger
    String str = "000012-345-6789";
    //Générer un modèle pour juger
    //Pattern p = Pattern.compile("\\d{2,4}-\\d{2,4}-\\d{4}.*"); //Correspondance du préfixe du numéro de téléphone
    //Pattern p = Pattern.compile(".*\\d{2,4}-\\d{2,4}-\\d{4}"); //Correspondance du suffixe du numéro de téléphone
    Pattern p = Pattern.compile(".*\\d{2,4}-\\d{2,4}-\\d{4}.*"); //Correspondance partielle du numéro de téléphone
    Matcher m = p.matcher(str);

    System.out.println(m.find()); //true
    }
}

Extraire la chaîne de caractères correspondante

• Préparer l'objet Pattern avec la méthode de compilation de la classe Pattern
• Créez un objet Macher qui recherche une chaîne de caractères à l'aide de la méthode matcher
• Répétez la correspondance avec while (match.find ()) jusqu'à ce que la méthode find devienne fausse, et obtenez la position de début (début), la position de fin (fin) et la chaîne de caractères correspondante (groupe) de la chaîne de caractères.
• group [0]: toute la chaîne correspondante
• group [1]: Premier élément de la chaîne de sous-correspondance

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Mobile est 0123-99-C'est 0000. La maison est 000-123-4567 et ainsi de suite.";
    var ptn = Pattern.compile("(\\d{2,4})-(\\d{2,4})-(\\d{4})");
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println("Position de départ:" + match.start());
      System.out.println("Position finale:" + match.end());
      System.out.println("Chaîne correspondante:" + match.group());
      System.out.println("Indicatif régional:" + match.group(1));
      System.out.println("Code de la ville:" + match.group(2));
      System.out.println("Numéro d'adhérant:" + match.group(3));
      System.out.println("-----");
    }
  }
}

Contrôle du comportement pendant la correspondance

• Vous pouvez changer le comportement lors de l'instanciation de la classe Pattern avec l'indicateur de correspondance.

CASE_INSENSITIVE

• Insensible à la casse

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Car le travail est [email protected]'est com. NEKO pour un usage privé@example.C'est com.";
    var ptn = Pattern.compile("[a-z0-9.!#$%&'*+/=?^_{|}~-]+@[a-z0-9-]+(\\.[a-z0-9-]+)*", Pattern.CASE_INSENSITIVE);
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println(match.group());
    }
  }
}

MULTILINE

• Changer le comportement de «^» et «$»
• ^ correspond non seulement au début mais aussi au numéro après le saut de ligne
• Dans le cas de $, il correspond également à la fin de la ligne

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Amis en première année\Je me demande si 100 personnes peuvent le faire\n";
    // var ptn = Pattern.compile("^\\d*");
    var ptn = Pattern.compile("^\\d*", Pattern.MULTILINE);
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println(match.group()); //1 100
    }
  }
}

DOTALL

• Changer le comportement de .
• Correspond à toutes les chaînes de caractères, y compris les sauts de ligne (\ n)
• Les chaînes de caractères peuvent être mises en correspondance sur une seule ligne (mode ligne unique)

import java.util.*;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var str = "Voulait se rencontrer\nVoulait se rencontrer\nVoulait se rencontrer\nYES";
    // var ptn = Pattern.compile("^.+");
    var ptn = Pattern.compile("^.+", Pattern.DOTALL);
    var match = ptn.matcher(str);
    while (match.find()) {
      System.out.println(match.group());
      //Voulait se rencontrer
      //Voulait se rencontrer
      //Voulait se rencontrer
      //YES
    }
  }
}

Drapeau intégré

• Le code suivant est le même
  • ?i ：CASE_INSENSITIVE
  • ?m ：MULTILINE
  • ?s ：DOTALL
  • ?u ：UNICODE_CASE
  • ?d ：UNIX_LINES
  • ?x ：COMMENTS

var ptn = Pattern.compile("(?i)[a-z0-9.!#$%&'*+/=?^_{|}~-]+@[a-z0-9-]+(\\.[a-z0-9-]+)*");

//var ptn = Pattern.compile("[a-z0-9.!#$%&'*+/=?^_{|}~-]+@[a-z0-9-]+(\\.[a-z0-9-]+)*", Pattern.CASE_INSENSITIVE);

Match le plus long / match le plus court

• ** <. +> ** Correspondance la plus longue (correspond à une chaîne aussi longue que possible)
• Dans <...>, (N'importe quel caractère) est + (1 caractère ou plus)
• Tous les caractères de balise sont affichés
• ** <. +?> ** Correspondance la plus courte (correspond à une chaîne aussi courte que possible)
• Sortez chaque caractère d'étiquette un par un

import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var tags = "<p><strong>NEKO</strong>site<a href='index.html'><img src='cat.jpg' /></a></p>";
    //Match le plus long
    //var ptn = Pattern.compile("<.+>"); //<p><strong>NEKO</strong>site<a href='index.html'><img src='cat.jpg' /></a></p>
    //Match le plus court
    var ptn = Pattern.compile("<.+?>");
    var match = ptn.matcher(tags);
    while (match.find()) {
      System.out.println(match.group());
      //<p>
      //<strong>
      //</strong>
      //<a href='index.html'>
      //<img src='cat.jpg' />
      //</a>
      //</p>
    }
  }
}

Capture nommée

• Nom et groupe de capture
• Accès avec groupe (" nom ")

import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {
    var msg = "Mobile est 0123-99-C'est 0000. La maison est 000-123-4567 et ainsi de suite.";
    var ptn = Pattern.compile("(?<area>\\d{2,4})-(?<city>\\d{2,4})-(?<local>\\d{4})");
    var match = ptn.matcher(msg);
    while (match.find()) {
      System.out.println("Position de départ:" + match.start());
      System.out.println("Position finale:" + match.end());
      System.out.println("Chaîne correspondante:" + match.group());
      System.out.println("Indicatif régional:" + match.group("area"));
      System.out.println("Code de la ville:" + match.group("city"));
      System.out.println("Numéro d'adhérant:" + match.group("local"));
      System.out.println("-----");
    }
  }
}

Retour référence

• Les chaînes correspondantes peuvent être référencées plus tard avec \\ 1

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main {
  //Retour référence
  public static void main(String args[]){
    String str1 = "My name is <div>Neko</div>";
    String str2 = "I am a <span>Cat</span>";
    String str3 = "<span>Hello World</div>";
    String regex = "<(div|span)>.*?<\\/\\1>";
    Pattern p = Pattern.compile(regex);
    System.out.println("modèle: " + regex);
    check(p, str1);
    check(p, str2);
    check(p, str3);
  }
  private static void check(Pattern p, String target){
    Matcher m = p.matcher(target);

    if (m.find()){
      System.out.println("Match! " + target);
    }else{
      System.out.println("Unmatch! " + target);
    }
  }
}

Look-ahead / look-ahead

• Jugez s'il correspond par la présence ou l'absence des chaînes de caractères précédentes et suivantes
• ** A (? = B) **: Correspond à A uniquement si B suit A
• ** A (?! B) **: Correspond à A seulement si B ne suit pas immédiatement A
• ** (? <= B) A **: Correspond à A uniquement s'il y a B immédiatement avant A
• ** (? <! B) A **: Correspond à A uniquement s'il n'y a pas de B immédiatement avant A

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main {

  private static void match(Pattern ptn, String input) {
    var match = ptn.matcher(input);
    while (match.find()) {
      System.out.println(match.group());
    }
    System.out.println("---");
  }

  public static void main(String[] args) {
    var re1 = Pattern.compile("ma(?=Oui)"); 
    var re2 = Pattern.compile("ma(?!Oui)"); 
    var re3 = Pattern.compile("(?<=。)ma");  
    var re4 = Pattern.compile("(?<!。)ma"); 
    var msg1 = "Mon oui est un chat";        
    var msg2 = "Je suis un chat. Mon nom n'y est pas encore.";
    match(re1, msg1); //ma
    match(re1, msg2); //---
    match(re2, msg1); //---
    match(re2, msg2); //ma,ma,ma
    match(re3, msg1); //---
    match(re3, msg2); //ma
    match(re4, msg1); //ma
    match(re4, msg2); //ma,ma
  }
}

Remplacement de la chaîne

• ** Méthode replaceAll **
• La chaîne de caractères après le remplacement peut inclure la chaîne de caractères avant le remplacement
• $ 0 chaîne de correspondance entière
• Première chaîne de sous-match
• Groupes de chapitres nommés disponibles avec $ {" name "}
• ** Méthode replaceFirst **: remplace uniquement la première chaîne
• • ** méthode de remplacement **: remplacement de la chaîne fixe

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main {

  public static void main(String[] args) {
    var str = "Cliquez ici pour les demandes de renseignements https://www.neko.com/est.";
    System.out.println(str.replaceAll(
        "(?i)http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\\\w ./?%&=-]*)?",
        "<a href=\"$0\">$0</a>"));
     //Nous contacter<a href="https://www.neko.com/">https://www.neko.com/</a>est.
  }
}

Division de chaîne

• ** méthode fractionnée **
• cf: la division de la classe strig compile chaque fois l'expression régulière
• Utilisez la classe Pattern lors de la réutilisation du même modèle

import java.util.regex.Pattern;
public class Main {
  //Un ou plusieurs chiffres+Split avec
  public static void main(String[] args) {
    var str = "Il y a 2 crocodiles et 22 crocodiles";
    var re = Pattern.compile("\\d{1,}sensationnel");
    var result = re.split(str);
    System.out.println(String.join(" ", result)); 
    //Il y a un écureuil dans le dos
  }
}