Les expressions régulières en Java

complément au cours sur les expressions régulières en PHP et en JavaScript,
à titre de comparaison.

1.  une expression régulière est une instance de la classe java.util.regex.Pattern,
2. sa mise en œuvre nécessite souvent la création d'une instance de java.util.regex.Matcher.
   

Pattern

1. Un pattern est créé par compilation d'une chaîne de caractères :
   Pattern ptr = Pattern.compile(chn);
   
   Cette chaîne se conforme à une syntaxe voisine de celles de Perl, de PHP et de JavaScript
   (voir la doc de Pattern).
   
   Exemples :
   String zip_code = "\\d{2}+ \\d{3}+"; // 26 340 avec un blanc après le département
   String tel_num = "(\\d{2}+ ){4}+\\d{2}+"; // 01 45 48 56 38, sans blanc derrière les derniers chiffres
   
   Attention ! le nombre de répétitions s'écrit avec un "+" suffixé et il faut doubler les backslashes.
   
   
2. Un pattern peut s'utiliser directement pour découper une chaîne en tronçons,
   par ptr.split(chn)
   le résultat étant naturellement un tableau de chaînes (String[]).
   
   Exemple (suite) : soit à découper une adresse de part et d'autre du code postal :
   "60 Avenue des Arbres écrits 26 400 Crest" ==> "60 Avenue des Arbres écrits" + "Crest".
   
   String adr = "60 Avenue des Arbres écrits  26 400 Crest";
   Pattern ptr = Pattern.compile(zip_code);
   String [] lieuLoc = ptr.split(adr);
   
   "60 Avenue des Arbres écrits" <= lieuLoc[0].trim()
   "Crest" <= lieuLoc[1].trim()

Matcher

1. Création : Matcher mtc = pattern.matcher(chaine);
   Exemple (suite) : Matcher mtc = ptr.matcher(adr);
   
   
2. Test de conformité globale (de la chaîne au pattern) :
   méthode matches() à valeurs booléennes
   if( mtc.matches() ){.....}
   
   
3. Filtrage des sous-chaînes conformes au pattern :
   méthode find() à valeurs booléennes et à effet de bord sur start et end
   
   • si l'appel mtc.find() renvoie vrai, alors
   • les attributs mtc.start et mtc.end repèrent le début et la fin de la sous-chaîne satisfaisante
   • et ladite sous-chaîne est obtenue par mtc.group()
     
   • l'appel suivant à  mtc.find() trouvera la sous-chaîne satisfaisante suivante, si elle existe, etc.
     
     
   Exemple (suite) : extraction du code postal de la chaîne-adresse
   
   if( mtc.find() ){
      String codPost = mtc.group();
         // équivalent à codPost = adr.substring(mtc.start(), mtc.end());
   }
    
   
4. Parenthèses capturantes (6/06/2011)
   La syntaxe est la même qu'en Perl.
   Les chaînes filtrées sont logées au sein du matcher dans les group, accessibles seulement après l'opération mtc.matches()
   Exemple de base :
           String contenu = ...;
        String expreg = ...;
        Pattern ptr = Pattern.compile(expreg);
        Matcher mtc = ptr.matcher(contenu);
        System.out.println(mtc.groupCount()); // déterminé sur expreg seul, avant le match
        if( mtc.matches() ) {
            for(int i=0; i<= mtc.groupCount(); i++ ){ // attention ! le dernier a pour indice groupCount()
                System.out.println(mtc.group(i));
            }
        }else{
            System.out.println("KO");
        }


Abréviations

• Pattern.matches(expreg, chaine)
  La séquence

  Pattern ptr = Pattern.compile(expreg);
  Matcher mtc = ptr.matcher(chaine);
  boolean b = mtc.matches();
  

  s'abrège en : boolean b = Pattern.matches(expreg, chaine);
  
  
• Sur une chaîne fixe on peut se contenter des méthodes de String : contains & split
  Exemple :   String nom =.....;

  if( nom.contains("/") ){
    String[] noms = nom.split("/");
    .....
  }else{
    .....
  }