expressions régulières Java

Expression régulière définit la chaîne de modèle.

Les expressions régulières peuvent être utilisés pour rechercher, modifier, ou le traitement de texte.

Les expressions régulières ne sont pas limités à une certaine langue, mais il y a des différences subtiles dans chaque langue.

Java Les expressions régulières Perl et est le plus similaire.

package java.util.regex comprend les trois catégories suivantes:

• catégories de motifs:

  motif de l'objet est une représentation régulière du compilateur d'expression. classe Motif n'a pas de constructeur public. Pour créer un objet de modèle, vous devez d'abord appeler sa méthode de compilation statique publique qui renvoie un objet Pattern. Cette méthode prend une expression régulière comme premier argument.

• catégories Matcher:

  objet Matcher est l'interprétation de la chaîne d'entrée et le fonctionnement correspondant du moteur. Comme la classe Motif, Matcher n'a pas de constructeur public. Vous devez appeler l'objet Motif matcher de méthode pour obtenir un objet Matcher.

• PatternSyntaxException:

  PatternSyntaxException est une classe d'exception non obligatoire qui représente un habitué des erreurs de syntaxe de motif d'expression.

groupe de capture

groupes de capture sont multiples caractères lorsqu'une seule des méthodes de traitement de l'unité, à travers les caractères groupés entre parenthèses pour créer.

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

groupe de capture en calculant la parenthèse ouverte numérotés de gauche à droite. Par exemple, dans l'expression ((A) (B (C))), il existe quatre de ces groupes:

• ((A) (B (C)))
• (A)
• (B (C))
• (C)

En appelant le matcher moyen objet GroupCount pour voir combien de paquets expression. méthode GroupCount renvoie un int représentant l'objet de matcher compte actuellement plusieurs groupes de capture.

Il y a un groupe spécial (groupe 0), il représente toujours l'expression entière. Le groupe n'a pas été inclus dans la valeur de retour GroupCount.

Exemples

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

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    public static void main( String args[] ){

      // 按指定模式在字符串查找
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // 创建 Pattern 对象
      Pattern r = Pattern.compile(pattern);

      // 现在创建 matcher 对象
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      } else {
         System.out.println("NO MATCH");
      }
   }
}

Les exemples ci-dessus les résultats compilés sont les suivants:

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

syntaxe d'expression régulière

méthodes de classe Matcher

Index Méthode

méthodes d'index fournissent des valeurs d'index utiles indiquent précisément où trouver les correspondances de chaînes d'entrée:

Méthodes de recherche

Méthodes utilisées pour vérifier la chaîne d'entrée et renvoie une valeur booléenne indiquant si oui ou non le motif est trouvé:

méthode de remplacement

Alternative est de remplacer une chaîne dans la méthode de saisie de texte:

début et fin de la méthode

Voici un exemple du nombre d'occurrences dans la chaîne d'entrée pour compter le mot «chat» apparaît:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT =
                                    "cat cat cat cattie cat";

    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // 获取 matcher 对象
       int count = 0;

       while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Les exemples ci-dessus les résultats compilés sont les suivants:

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Ceci peut être vu en utilisant l'exemple des limites de mots, de veiller à ce que la lettre "c" "a" "t" est pas seulement de longues sous-mot. Il fournit également des informations utiles sur la chaîne d'entrée est adaptée positions.

méthode de début retourne l'opération au cours du match précédent, à partir de l'index donné groupe capturé séquence initiale, la fin de la méthode d'appariement le dernier indice plus un caractère.

allumettes et méthode de regarderLes

les allumettes et les méthodes de regarderLes sont utilisés pour essayer de faire correspondre une séquence de motif d'entrée. Ils sont différents des exigences de l'intégralité du match séquence de matcher, mais regarderLes pas nécessaire.

Ces deux méthodes sont souvent utilisés dans la chaîne d'entrée commence.

Grâce à l'exemple suivant pour expliquer cette fonction:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);

       System.out.println("Current REGEX is: "+REGEX);
       System.out.println("Current INPUT is: "+INPUT);

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

Les exemples ci-dessus les résultats compilés sont les suivants:

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

méthodes replaceFirst et replaceAll

replaceFirst et replaceAll méthode utilisée pour remplacer le texte correspondant expression régulière. La différence est, replaceFirst remplacer le premier match, ReplaceAll remplacer toutes les correspondances.

L'exemple suivant pour expliquer cette fonction:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

Les exemples ci-dessus les résultats compilés sont les suivants:

The cat says meow. All cats say meow.

méthodes appendReplacement et appendTail

classe Matcher fournit également une méthode pour appendTail appendReplacement et remplacer du texte:

Regardez l'exemple suivant pour expliquer cette fonction:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // 获取 matcher 对象
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Les exemples ci-dessus les résultats compilés sont les suivants:

-foo-foo-foo-

méthodes de la classe PatternSyntaxException

PatternSyntaxException est une classe d'exception non obligatoire, ce qui indique un habitué des erreurs de syntaxe de motif d'expression.

classe PatternSyntaxException fournit les méthodes suivantes pour nous aider à voir ce que l'erreur est survenue.