Les groupes de capture sont divisés en :
- Groupes de capture ordinaires (Expression)
- Groupes de capture nommés (?Expression)
Groupes de capture ordinaires
En partant du côté gauche de la regex, chaque occurrence d'une parenthèse ouvrante "(" est comptée comme un groupe, les numéros de groupe commençant à 1. 0 représente l'expression entière.
Pour la chaîne de temps : 2017-04-25, l'expression est la suivante
(\\d{4})-((\\d{2})-(\\d{2}))
Il y a 4 parenthèses ouvrantes, donc il y a 4 groupes :
| Number |
Groupe de capture |
Correspondance |
| 0 |
(\d{4})-((\d{2})-(\d{2})) |
2017-04-25 |
| 1 |
(\d{4}) |
2017 |
| 2 |
((\d{2})-(\d{2})) |
04-25 |
| 3 |
(\d{2}) |
04 |
| 4 |
(\d{2}) |
25 |
public static final String DATE_STRING = "2017-04-25";
public static final String P_COMM = "(\\d{4})-((\\d{2})-(\\d{2}))";
Pattern pattern = Pattern.compile(P_COMM);
Matcher matcher = pattern.matcher(DATE_STRING);
matcher.find();
System.out.printf("\nmatcher.group(0) valeur:%s", matcher.group(0));
System.out.printf("\nmatcher.group(1) valeur:%s", matcher.group(1));
System.out.printf("\nmatcher.group(2) valeur:%s", matcher.group(2));
System.out.printf("\nmatcher.group(3) value:%s", matcher.group(3));
System.out.printf("\nmatcher.group(4) value:%s", matcher.group(4));
Groupes de capture nommés
Chaque groupe de capture commençant par une parenthèse ouvrante est immédiatement suivi de?, puis de l'expression régulière.
Pour la chaîne de temps : 2017-04-25, l'expression est la suivante :
(?<year>\\d{4})-(?<md>(?<month>\\d{2})-(?<date>\\d{2}))
Il y a 4 groupes de capture nommés, à savoir :
| Number |
Name |
Groupe de capture |
Correspondance |
| 0 |
0 |
(?\d{4})-(?(?\d{2})-(?\d{2})) |
2017-04-25 |
| 1 |
année |
(?\d{4})- |
2017 |
| 2 |
md |
(?(?\d{2})-(?\d{2})) |
04-25 |
| 3 |
month |
(?\d{2}) |
04 |
| 4 |
date |
(?\d{2}) |
25 |
Les groupes de capture nommés peuvent également utiliser des nombres pour obtenir les valeurs correspondantes.
public static final String P_NAMED = "(?<year>\\d{4})-(?<md>(?<month>\\d{2})-(?<date>\\d{2}))";
public static final String DATE_STRING = "2017-04-25";
Pattern pattern = Pattern.compile(P_NAMED);
Matcher matcher = pattern.matcher(DATE_STRING);
matcher.find();
System.out.printf("\n===========Obtenir par nom=============");
System.out.printf("\nmatcher.group(0) valeur:%s", matcher.group(0));
System.out.printf("\n matcher.group('year') valeur:%s", matcher.group("year"));
System.out.printf("\nmatcher.group('md') valeur:%s", matcher.group("md"));
System.out.printf("\nmatcher.group('month') valeur:%s", matcher.group("month"));
System.out.printf("\nmatcher.group('date') valeur:%s", matcher.group("date"));
matcher.reset();
System.out.printf("\n===========Obtenir par numéro=============");
matcher.find();
System.out.printf("\nmatcher.group(0) valeur:%s", matcher.group(0));
System.out.printf("\nmatcher.group(1) valeur:%s", matcher.group(1));
System.out.printf("\nmatcher.group(2) valeur:%s", matcher.group(2));
System.out.printf("\nmatcher.group(3) value:%s", matcher.group(3));
System.out.printf("\nmatcher.group(4) value:%s", matcher.group(4));
PS : Groupes non capturants
Immédiatement après la parenthèse ouvrante, faites suivre de?:, puis ajoutez l'expression regex pour former un groupe non capturant.(?:Expression)。
Pour la chaîne de temps : 2017-04-25, l'expression est la suivante :
(?:\\d{4})-((\\d{2})-(\\d{2}))
Bien que cette regex ait quatre parenthèses ouvrantes, théoriquement il y a 4 groupes de capture. Mais le premier groupe(?:\d{4}), est en fait ignoré. Lors de l'utilisation de matcher.group(4), le système lèvera une erreur.
| Number |
Groupe de capture |
Correspondance |
| 0 |
(\d{4})-((\d{2})-(\d{2})) |
2017-04-25 |
| 1 |
((\d{2})-(\d{2})) |
04-25 |
| 2 |
(\d{2}) |
04 |
| 3 |
(\d{2}) |
25 |
public static final String P_UNCAP = "(?:\\d{4})-((\\d{2})-(\\d{2}))";
public static final String DATE_STRING = "2017-04-25";
Pattern pattern = Pattern.compile(P_UNCAP);
Matcher matcher = pattern.matcher(DATE_STRING);
matcher.find();
System.out.printf("\nmatcher.group(0) valeur:%s", matcher.group(0));
System.out.printf("\nmatcher.group(1) valeur:%s", matcher.group(1));
System.out.printf("\nmatcher.group(2) valeur:%s", matcher.group(2));
System.out.printf("\nmatcher.group(3) value:%s", matcher.group(3));
System.out.printf("\nmatcher.group(4) valeur:%s", matcher.group(4));
Résumé
- Les groupes de capture ordinaires sont pratiques à utiliser ;
- Les groupes de capture nommés sont clairs à utiliser ;
- Les groupes non capturants n'ont actuellement aucune utilité dans les projets.
URL d'origine : https://blog.csdn.net/just4you/article/details/70767928