Expression régulière Java
Une chaîne est en fait une expression régulière simple. Par exemple, l'expression régulière Hello World correspond à la chaîne "Hello World".
. (Dot) est également une expression régulière, il correspond à n'importe quel caractère tel que "a" ou "1".
Le package java.util.regex comprend principalement les trois catégories suivantes:
Classe Pattern: l'
objet pattern est une représentation compilée d'une expression régulière. La classe Pattern n'a pas de constructeur public. Pour créer un objet Pattern, vous devez d'abord appeler sa méthode de compilation statique publique, qui renvoie un objet Pattern. Cette méthode accepte une expression régulière comme premier paramètre.
Classe Matcher: l'
objet Matcher est un moteur d'interprétation et de mise en correspondance des chaînes d'entrée. Comme la classe Pattern, Matcher n'a pas de constructeur public. Vous devez appeler la méthode matcher de l'objet Pattern pour obtenir un objet Matcher.
PatternSyntaxException:
PatternSyntaxException est une classe d'exception non obligatoire, qui représente une erreur de syntaxe dans un modèle d'expression régulière.
Les expressions régulières sont utilisées dans les exemples suivants. Runoob. Est utilisé pour déterminer si la chaîne contient des sous-chaînes runoob:
import java.util.regex.*;
class RegexExample1{
public static void main(String args[]){
String content = "I am noob " +
"from runoob.com.";
String pattern = ".*runoob.*";
boolean isMatch = Pattern.matches(pattern, content);
System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);
}
}
/*实例输出结果为：
字符串中是否包含了 'runoob' 子字符串? true
Syntaxe des expressions régulières
Dans d'autres langages, \ signifie: je veux insérer une barre oblique inverse normale (littérale) dans l'expression régulière, veuillez ne pas lui donner de signification particulière.
En Java, \ signifie: je veux insérer une barre oblique inverse dans une expression régulière, donc les caractères qui suivent ont une signification particulière.
personnage
La description
\
Marquez le caractère suivant comme caractère spécial, texte, référence arrière ou caractère d'échappement octal. Par exemple, "n" correspond au caractère "n". "\ n" correspond à un caractère de nouvelle ligne. La séquence "\\" correspond à "\", "\ (" correspond "(".
^
Correspond à la position au début de la chaîne d'entrée. Si la propriété Multiline de l'objet RegExp est définie, ^ correspondra également à la position après "\ n" ou "\ r".
$
Correspond à la position à la fin de la chaîne d'entrée. Si la propriété Multiline de l'objet RegExp est définie, $ correspondra également à la position avant "\ n" ou "\ r".
Correspond à zéro ou plusieurs fois le caractère ou la sous-expression précédent. Par exemple, zo * correspond à "z" et "zoo". * Équivalent à {0,}.
Faites correspondre le caractère ou la sous-expression précédent une ou plusieurs fois. Par exemple, "zo +" correspond à "zo" et "zoo" mais pas à "z". + Équivaut à {1,}.
?
Correspond à zéro ou une fois le caractère ou la sous-expression précédent. Par exemple, "do (es)?" Correspond à "do" ou "do" dans "does". ? Équivalent à {0,1}.
{n}
n est un entier non négatif. Correspond exactement n fois. Par exemple, "o {2}" ne correspond pas au "o" de "Bob", mais il correspond aux deux "o" de "food".
{n,}
n est un entier non négatif. Correspond au moins n fois. Par exemple, "o {2,}" ne correspond pas au "o" de "Bob", mais correspond à tous les o de "foooood". "o {1,}" équivaut à "o +". "o {0,}" équivaut à "o *".
{n, m}
m et n sont des entiers non négatifs, où n <= m. Correspond au moins n fois et au plus m fois. Par exemple, "o {1,3}" correspond aux trois premiers o de "fooooood". «o {0,1}» équivaut à «o?». Remarque: vous ne pouvez pas insérer d'espaces entre les virgules et les nombres.
?
Lorsque ce caractère suit immédiatement tout autre qualificatif (*, +,?, {N}, {n,}, {n, m}), le mode de correspondance est "non gourmand". Le modèle "non gourmand" correspond à la chaîne recherchée aussi court que possible, tandis que le motif "gourmand" par défaut correspond à la chaîne recherchée aussi longtemps que possible. Par exemple, dans la chaîne "oooo", "o +?" Correspond à un seul "o" et "o +" correspond à tous les "o".
.
Correspond à n'importe quel caractère unique sauf "\ r \ n". Pour faire correspondre n'importe quel caractère, y compris "\ r \ n", utilisez un modèle tel que "[\ s \ S]".
(modèle)
Faites correspondre le modèle et capturez la sous-expression correspondante. Vous pouvez utiliser les attributs $ 0 ... $ 9 pour récupérer les correspondances capturées à partir de l'ensemble de "correspondance" de résultats. Pour faire correspondre les caractères entre crochets (), utilisez "(" ou ")".
(?:modèle)
Correspond au modèle mais ne capture pas la sous-expression correspondante, c'est-à-dire qu'il s'agit d'une correspondance sans capture et ne stocke pas la correspondance pour une utilisation ultérieure. Ceci est utile lors de la combinaison de parties de motif avec le caractère "ou" (|). Par exemple, «industr (?: Y | s) est une expression plus économique que« industrie | industries ».
(? = motif)
Exécutez une sous-expression de recherche anticipée de prédiction directe qui correspond à la chaîne au début du modèle de correspondance de chaîne. C'est une correspondance sans capture, c'est-à-dire une correspondance qui ne peut pas être capturée pour une utilisation ultérieure. Par exemple, «Windows (? = 95 | 98 | NT | 2000)» correspond à «Windows» dans «Windows 2000» mais pas à «Windows» dans «Windows 3.1». La prédiction n'occupe pas d'abord les caractères, c'est-à-dire qu'après qu'une correspondance se produit, la recherche de la correspondance suivante suit immédiatement la correspondance précédente, pas après les caractères qui composent la prédiction en premier.
(?!modèle)
Sous-expression qui effectue une recherche anticipée de prédiction arrière qui correspond à une chaîne de recherche qui n'est pas au point de départ de la chaîne qui correspond au modèle. C'est une correspondance sans capture, c'est-à-dire une correspondance qui ne peut pas être capturée pour une utilisation ultérieure. Par exemple, «Windows (?! 95 | 98 | NT | 2000)» correspond à «Windows» dans «Windows 3.1» mais pas à «Windows» dans «Windows 2000». La prédiction n'occupe pas d'abord les caractères, c'est-à-dire qu'après qu'une correspondance se produit, la recherche de la correspondance suivante suit immédiatement la correspondance précédente, pas après les caractères qui composent la prédiction en premier.
x | y
Faites correspondre x ou y. Par exemple, «z | food» correspond à «z» ou «food». '(z | f) ood' correspond à "zood" ou "food".
[xyz]
jeu de caractères. Correspond à n'importe quel caractère contenu. Par exemple, "[abc]" correspond au "a" dans "plain".
[^ xyz]
Jeu de caractères inversé. Correspond à tous les caractères non inclus. Par exemple, "[^ abc]" correspond à "p", "l", "i", "n" dans "plain".
[az]
Gamme de caractères. Correspond à n'importe quel caractère de la plage spécifiée. Par exemple, "[az]" correspond à n'importe quelle lettre minuscule dans la plage "a" à "z".
[^ az]
Caractère de plage inversée. Correspond à tous les caractères ne figurant pas dans la plage spécifiée. Par exemple, "[^ az]" correspond à tout caractère qui n'est pas dans la plage de "a" à "z".
\ b
Faites correspondre une limite de mot, c'est-à- dire la position entre un mot et un espace . Par exemple, "er \ b" correspond au "er" dans "jamais" mais pas au "er" dans "verbe".
\ B
Correspondance de limite non mot. "Er \ B" correspond au "er" dans "verbe", mais pas au "er" dans "jamais".
\ cx
Correspond au caractère de contrôle indiqué par x. Par exemple, \ cM correspond à Control-M ou au retour chariot. La valeur de x doit être comprise entre AZ ou az. Si ce n'est pas le cas, supposez que c est le caractère "c" lui-même.
\ré
Correspondance de caractères numériques. Équivalent à [0-9].
\RÉ
Les caractères non numériques correspondent. Équivaut à [^ 0-9].
\F
Correspondances de flux de formulaire. Équivalent à \ x0c et \ cL.
\ n
Les caractères de nouvelle ligne correspondent. Équivalent à \ x0a et \ cJ.
\ r
Correspond à un caractère de retour chariot. Équivalent à \ x0d et \ cM.
\ s
Faites correspondre tous les caractères vides, y compris les espaces, les tabulations, les flux de formulaire, etc. Équivaut à [\ f \ n \ r \ t \ v].
\ S
Correspond à n'importe quel caractère non blanc. Équivaut à [^ \ f \ n \ r \ t \ v].
\ t
Correspondance de tabulation. Équivalent à \ x09 et \ cI.
\ v
Correspondance des onglets verticaux. Équivalent à \ x0b et \ cK.
\ w
Correspond à n'importe quel caractère de mot, y compris les traits de soulignement. Équivalent à "[A-Za-z0-9_]".
\ W
Correspond à n'importe quel caractère autre qu'un mot. Équivaut à "[^ A-Za-z0-9_]".
\ xn
Correspond à n, où n est un code d'échappement hexadécimal. Le code d'échappement hexadécimal doit comporter exactement deux chiffres. Par exemple, "\ x41" correspond à "A". "\ x041" équivaut à "\ x04" & "1". Les codes ASCII sont autorisés dans les expressions régulières.
\sur une
Correspond à num, où num est un entier positif. Pour capturer les références arrière correspondantes. Par exemple, "(.) \ 1" correspond à deux caractères identiques consécutifs.
\ n
Identifie un code d'échappement octal ou une référence arrière. S'il y a au moins n sous-expressions capturées avant \ n, alors n est une référence arrière. Sinon, si n est un nombre octal (0-7), alors n est un code d'échappement octal.
\ nm
Identifie un code d'échappement octal ou une référence arrière. S'il y a au moins nm sous-expressions de capture avant \ nm, alors nm est une référence arrière. S'il y a au moins n captures avant \ nm, alors n est une référence arrière suivie du caractère m. Si aucune des conditions précédentes n'existe, \ nm correspond à la valeur octale nm, où n et m sont des nombres octaux (0-7).
\ nml
Lorsque n est un nombre octal (0-3), m et l sont des nombres octaux (0-7), correspondent au code d'échappement octal nml.
\un
Correspond à n, où n est un caractère Unicode représenté par un nombre hexadécimal à quatre chiffres. Par exemple, \ u00A9 correspond au symbole du droit d'auteur (©).
Comment écrire des expressions régulières en Java
- Correspond juste à
1) Méthode de mise en œuvre 1, correspond à un nombre.
public void regex1() {
//要匹配的字符
String str = "8";
//正则表达式
String regex = "[0-9]";
//返回匹配的结果，匹配成功就返回true，失败就返回false，此次匹配返回true。
boolean flag = Pattern.matches(regex, str);
System.out.println(flag);
}
2) Méthode de mise en œuvre 2, correspond à 3 à 5 lettres, sans majuscules et minuscules, y compris 3 et 5.
public void regex2() {
//要匹配的字符
String str = "hello";
//正则表达式
String regex = "[a-zA-Z]{3,5}";
//输出匹配的结果, 此次匹配返回true。
System.out.println(str.matches(regex));
}
3). Mise en œuvre 3 (cette implémentation est la plus rapide), correspondance des numéros de téléphone à 11 chiffres, règles de correspondance: le premier chiffre est 1, le deuxième chiffre est l'un des 2, 3, 7, 8 et le 9 suivant 4 n'est pas inclus dans les chiffres.
public void regex3() {
//要匹配的字符
String str = "13656231253";
//正则表达式
String regex = "1[2378][0-35-9]{9}";
//将给定的正则表达式编译为模式。 如果匹配需求较多，且需用同相同的regex去匹配，就可将这句写到静态模块里面，用的时候直接使用实例p
Pattern p = Pattern.compile(regex);
//创建一个匹配器，匹配给定的输入与此模式。
Matcher m = p.matcher(str);
//尝试将整个区域与模式进行匹配。
boolean flag = m.matches();
//输出匹配结果，此次结果为true
System.out.println(flag);
}
- remplacer.
public void regexReplace () {
//要匹配的字符
String str = "12a6B985Ccv65";
//正则表达式
String regex = "[a-zA-Z]+";
//正则表达式
String regex2 = "\\d+";
//将字符串中英文字母替换为&符号，输出12&6&985&65
System.out.println(str.replaceAll(regex, "&"));
//将字符串中单个数字或者连续的数字替换为0，输出0a0B0Ccv0
System.out.println(str.replaceAll(regex2,"0"));
}
- Couper, couper la chaîne selon les lettres majuscules.
public void outputStr() {
String str = "oneTtowTthreeDfourJfive";
String regex = "[A-Z]";
String[] arr = str.split(regex);
for (String s: arr) {
System.out.print(s + " ");
}
}
输出：one tow three four five
start method
Voici un exemple de comptage du nombre d'occurrences du mot "cat" dans la chaîne d'entrée:
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());
}
}
}
/*以上实例编译运行结果如下：
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
Les méthodes matches et lookingAt
sont utilisées pour essayer de faire correspondre un modèle de séquence d'entrée. La différence entre eux est que les correspondances nécessitent que la séquence entière corresponde, contrairement à lookingAt.
Bien que la méthode lookingAt n'ait pas besoin de correspondre à la phrase entière, elle doit correspondre à partir du premier caractère.
Ces deux méthodes sont souvent utilisées au début de la chaîne d'entrée.
Nous utilisons 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 final String INPUT2 = "ooooofoooooooooooo";
private static Pattern pattern;
private static Matcher matcher;
private static Matcher matcher2;
public static void main( String args[] ){
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
matcher2 = pattern.matcher(INPUT2);
System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);
System.out.println("Current INPUT2 is: "+INPUT2);
System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
System.out.println("lookingAt(): "+matcher2.lookingAt());
}
}
/*以上实例编译运行结果如下：
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
Current INPUT2 is: ooooofoooooooooooo
lookingAt(): true
matches(): false
lookingAt(): false
Méthodes replaceFirst et replaceAll Les méthodes
replaceFirst et replaceAll sont utilisées pour remplacer le texte correspondant aux expressions régulières. La différence est que replaceFirst remplace la première correspondance et replaceAll remplace toutes les correspondances.
L'exemple suivant explique 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);
}
}
Méthodes appendReplacement et appendTail La
classe Matcher fournit également des méthodes appendReplacement et appendTail pour le remplacement de texte:
Consultez 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 = "aabfooaabfooabfoobkkk";
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());
}
}
/*以上实例编译运行结果如下：
-foo-foo-foo-kkk
Un merci spécial à
la partie ci-dessus du code commuté
Auteur: Vic_is_new_Here
lien: https: //www.jianshu.com/p/3c076c6b2dc8
Source: Jane books