Explication détaillée et utilisation : analyse des expressions régulières Java

Explication détaillée et utilisation des expressions régulières Java

L'expression régulière (expression régulière) est un puissant outil de traitement de texte largement utilisé dans divers langages de programmation. En Java, nous pouvons utiliser des expressions régulières pour réaliser des opérations telles que la correspondance, le remplacement et la division de chaînes. Cet article présentera en détail l'utilisation des expressions régulières Java et donnera des exemples de code spécifiques.

1. Syntaxe des expressions régulières

La syntaxe des expressions régulières de Java est cohérente avec la syntaxe des expressions régulières standard. Voici quelques métacaractères d'expressions régulières couramment utilisés et leur signification :

• d : correspond à n'importe quel nombre.
• D : fait correspondre n'importe quel caractère non numérique.
• w : Faites correspondre n'importe quelle lettre, chiffre ou trait de soulignement.
• W : fait correspondre n'importe quel caractère autre qu'une lettre, un chiffre ou un trait de soulignement.
• s : fait correspondre n'importe quel caractère d'espacement, y compris l'espace, la tabulation, la nouvelle ligne, etc.
• S : fait correspondre n'importe quel caractère autre qu'un espace.
• : Faites correspondre une limite de mot.
• ^ : Faites correspondre la position de départ de la chaîne.
• $ : correspond à la position finale de la chaîne.
• . : Faites correspondre n'importe quel personnage.
• * : Faites correspondre zéro ou plusieurs éléments précédents.
• + : Faites correspondre un ou plusieurs éléments précédents.
• ? : Faites correspondre zéro ou un élément précédent.
• {n} : fait correspondre l'élément précédent exactement n fois.
• {n,} : fait correspondre l'élément précédent au moins n fois.
• {n,m} : fait correspondre l'élément précédent au moins n fois et au plus m fois.
• [...] : Faites correspondre n'importe quel caractère entre crochets.
• ¹ : correspond à n'importe quel caractère à l'exception des caractères entre crochets.

Il existe de nombreux autres métacaractères et règles de grammaire qui peuvent être utilisés de manière flexible en fonction de besoins spécifiques.

2. Classe Pattern

En Java, la classe Pattern est une représentation compilée d'une expression régulière. Nous pouvons compiler la chaîne d'expression régulière et générer un objet Pattern via la méthode statique compile() fournie par la classe Pattern. Par exemple : compile()来编译正则表达式字符串，生成一个Pattern对象。例如：

String regex = "\d+";
Pattern pattern = Pattern.compile(regex);

3. Matcher类

Matcher类是所有正则表达式匹配操作的引擎。我们可以通过Pattern对象的matcher()方法来创建一个Matcher对象。

• matches()方法：用于测试正则表达式是否匹配整个字符串。例如：

String regex = "hello";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher("hello world");
boolean matched = matcher.matches();
System.out.println(matched); // 输出：true

• find()方法：用于查找字符串中与正则表达式匹配的子序列。例如：

String regex = "\d+";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher("abc123def");
while (matcher.find()) {
    System.out.println(matcher.group());
}

以上代码输出结果为：

123

• replaceAll()

  String regex = "\btom\b";
  Pattern pattern = Pattern.compile(regex);
  Matcher matcher = pattern.matcher("I love tom and tom loves me");
  String result = matcher.replaceAll("Jerry");
  System.out.println(result); // 输出：I love Jerry and Jerry loves me
Classe Matcher

4. La classe Matcher est le moteur de toutes les opérations de correspondance d'expressions régulières. Nous pouvons créer un objet Matcher via la méthode matcher() de l'objet Pattern.

Méthode matches() : utilisée pour tester si l'expression régulière correspond à la chaîne entière. Par exemple : méthode

String regex = "^1[3-9]\d{9}$";
Pattern pattern = Pattern.compile(regex);
String phone = "13612345678";
boolean isValid = pattern.matcher(phone).matches();
System.out.println(isValid); // 输出：true

• find() : utilisée pour rechercher des sous-séquences dans une chaîne qui correspondent à des expressions régulières. Par exemple :

String regex = "<a\s.*?href="([^"]+)".*?>";
Pattern pattern = Pattern.compile(regex);
String html = "<a href="http://www.example.com">Example</a>";
Matcher matcher = pattern.matcher(html);
while (matcher.find()) {
    System.out.println(matcher.group(1));
}

• Le résultat de sortie du code ci-dessus est :

http://www.example.com

Méthode replaceAll() : utilisée pour remplacer la partie de la chaîne qui correspond à l'expression régulière. Par exemple :

String regex = "\b\w+\b";
Pattern pattern = Pattern.compile(regex);
String text = "Hello world, I love Java!";
Matcher matcher = pattern.matcher(text);
List<String> words = new ArrayList<>();
while (matcher.find()) {
    words.add(matcher.group());
}
System.out.println(words);

• Exemples spécifiques

Voici quelques scénarios courants d'utilisation d'expressions régulières et des exemples de code correspondants :

Vérifiez si le numéro de téléphone mobile est légal :

---

[Hello, world, I, love, Java]

1. Extraire des liens dans du texte HTML :
rrreee

Le résultat de sortie du code ci-dessus est : 🎜rrreee🎜🎜Diviser la chaîne en une liste de mots : 🎜🎜rrreee🎜Le résultat de sortie du code ci-dessus est : 🎜rrreee🎜Résumé : 🎜Cet article présente l'utilisation des expressions régulières Java en détail, et des exemples de code spécifiques sont donnés. En apprenant la syntaxe des expressions régulières et l'utilisation des classes Pattern et Matcher, nous pouvons utiliser de manière flexible des expressions régulières pour traiter des chaînes. J'espère que cet article pourra vous aider à comprendre et à utiliser les expressions régulières Java. 🎜🎜🎜🎜... 🎜↩🎜🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!