1. regex (expression régulière) : RegularExpressions (remplaçant StringTokenizer) ; un outil puissant pour le traitement de chaînes populaire sous Unix, Perl est encore meilleur en utilisant regex ;
Principalement utilisé pour la correspondance, la recherche et le remplacement de chaînes. Par exemple : la correspondance IP (plage inférieure à 256) est facile à utiliser avec des expressions régulières ; extraire un grand nombre d'adresses e-mail de pages Web pour envoyer du spam ; Contient Matcher (le résultat de la correspondance d'une chaîne avec un modèle) et un modèle.
Copiez le code comme suit :
/*
* Indique si cette chaîne correspond à l'expression régulière donnée (également une chaîne).
*/
System.out.println("abc".matches("..."));//Chaque "." représente un caractère
Copiez le code comme suit :
/*
* Remplacez tous les nombres de la chaîne par "-". La méthode ordinaire nécessite que charAt soit jugé un par un ;
* "//d" représente n'importe quel nombre ou remplacez-le par "[0-9]" ;
* "//D" représente tout élément autre qu'un chiffre ou remplacé par "[^0-9]"
*/
System.out.println("ab54564654sbg48746bshj".replaceAll("[0-9]", "-"));//Chaque "."
deux,
Copiez le code comme suit :
/*
* compile compile l'expression régulière donnée dans le modèle (chaque compilation prend du temps) ; {3} signifie exactement trois fois.
* X{n} X, exactement n fois
* X{n,} X, au moins n fois
* X{n,m} X, au moins n fois, mais pas plus de m fois
*/
Modèle p = Pattern.compile("[az]{3}");
Matcher m = p.matcher("ggs");//Créer un matcher qui correspond à l'entrée donnée avec ce modèle. En interne, un automate d'état prioritaire est effectivement créé (principe de compilation)
//La chaîne à faire correspondre dans matcher et matches est en fait CharSequence (interface), mais String implémente cette interface et a un polymorphisme
System.out.println(m.matches());//Si c'est "ggss", il ne correspondra pas
//Vous pouvez toujours directement "ggs".matches("[az]{3}"), mais ce qui précède a des avantages, au moins c'est plus efficace, et Pattern et Matcher fournissent de nombreuses fonctions
3. Appelez le méta-caractère dans l'expression régulière ". * +" ; ctrl + shift + "/" signifie commentaire, remplacez-le par "/" pour supprimer le commentaire.
Copiez le code comme suit :
"a".matches(".");//true, "." représente n'importe quel caractère, y compris les caractères chinois
"aa".matches("aa");//true, c'est-à-dire que les chaînes ordinaires peuvent également être utilisées comme expressions régulières
/*
* vrai, "*" signifie 0 caractère ou plus, mais les caractères suivants doivent être identiques au premier.
* Sinon, c'est faux, c'est-à-dire qu'il est jugé si la chaîne est une chaîne composée de caractères uniques.
*/
"aaaa".matches("a*");
"".matches("a*");//true
"aaa".matches("a?");//true, une fois ou 0 fois
"".matches("a?");//true
"a".matches("a?");//true
"544848154564113".matches("//d{3,100}");//true
// Il s'agit du jugement IP le plus simple, mais s'il dépasse 255, il ne peut pas être jugé.
"192.168.0.aaa".matches("//d{1,3}//.//d{1,3}//.//d{1,3}//d{1,3}" );
"192".matches("[0-2][0-9][0-9]");
4. [abc] signifie correspondre à n'importe quel caractère ; [^abc] signifie un caractère autre que abc (doit toujours être une lettre, et false sera renvoyé s'il s'agit d'une chaîne vide) ; "[az ]|[AZ]" est une certaine lettre majuscule ou minuscule ; [AZ&&[ABS]] désigne l'une des lettres majuscules et ABS.
Copiez le code comme suit :
//J'ai trouvé qu'il n'y a pas de différence entre | et ||, mais il y a une différence entre & et &&. Je ne sais pas si c'est la bonne façon de le comprendre.
System.out.println("C".matches("[AZ&&[ABS]]"));//false
System.out.println("C".matches("[AZ&[ABS]]"));//true
System.out.println("A".matches("[AZ&&[ABS]]"));//true
System.out.println("A".matches("[AZ&[ABS]]"));//true
System.out.println("C".matches("[AZ|[ABS]]"));//true
System.out.println("C".matches("[AZ||[ABS]]"));//true
5. Caractères de mot /w : [a-zA-Z_0-9] lors de la correspondance des noms d'utilisateur ; /s caractères vides : [ /t/n/x0B/f/r] ; ] ;/W caractères autres que des mots : [^/w].
Copiez le code comme suit :
" /n/t/r".matches("//s{4}");//true
" ".matches("//S");//false
"a_8".matches("//w{3}");//true
//"+" signifie une ou plusieurs fois
"abc888&^%".matches("[az]{1,3}//d+[&^#%]+");//true
/*
* Le caractère à faire correspondre n'est qu'une barre oblique inverse, mais il ne peut pas être écrit sous la forme "/" puis combiné avec le suivant ",
* Le précédent « ne peut pas correspondre » entraînera CE.
* ne peut pas être suivi de "//", sinon une erreur d'exécution se produira (pas de problème de compilation), il faut l'écrire sous la forme "////"
*/
System.out.println("//".matches("////"));//true
6. Classe de caractères POSIX (US-ASCII uniquement)
Copiez le code comme suit :
/p{Lower} Caractères alphabétiques minuscules : [az] ;/p{Upper} Caractères alphabétiques majuscules : [AZ] ;/p{ASCII} Tous les ASCII : [/x00-/x7F] ;/p{Alpha} Caractères alphabétiques : [/p{Lower}/p{Upper}] ;/p{Digit} Nombre décimal : [0-9].
7. Correspondant aux limites
^ Début de ligne $ Fin de ligne/b Limite de mot/B Limite de non-mot/A Début de la saisie/G Fin de la correspondance précédente/Z Fin de la saisie, utilisée uniquement pour le dernier terminateur (le cas échéant)
/z fin de l'entrée
Copiez le code comme suit :
"hello world".matches("^h.*");//Le début de la ligne ^
"bonjour tout le monde".matches(".*ld$");//Fin de $line
"bonjour tout le monde".matches("^h[az]{1,3}o//b.*");///limite de mot
"helloworld".matches("^h[az]{1,3}o//b.*");
" /n".matches("^[//s&&[^//n]]*//n$");//Juge les lignes vides, qui commencent par un caractère vide
8. Vous pouvez également utiliser m.start() et m.end() sous la méthode find pour renvoyer le suivant entre la position de début et la position de fin ; s'il ne peut pas être trouvé, une erreur se produira.
Copiez le code comme suit :
Modèle p = Pattern.compile("//d{3,5}");
Chaîne s = "133-34444-333-00" ;
Matcher m = p.matcher(s);
m.matches();//matches correspond à toutes les chaînes
m.reset();
/*
* Si la méthode de réinitialisation est appelée en premier ci-dessous, vrai, vrai, vrai, faux sera affiché.
* Sinon, l'avant-dernière recherche renvoie également false.
*Les raisons sont les suivantes :
* correspond au premier "-" et constate qu'il ne correspond pas, mais ces quatre caractères ont été mangés. La correspondance recommencera à partir de.
* 34444 commence et la deuxième recherche commence à 333, car find correspond à la sous-séquence suivante.
* La méthode de réinitialisation permet aux allumettes de recracher la chaîne mangée par les allumettes.
* En résumé : la réinitialisation doit être utilisée entre les correspondances et la recherche, car elles s'influencent mutuellement
*
*/
m.find();
m.find();
m.find();//Essayez de trouver la sous-séquence suivante de la séquence d'entrée qui correspond à ce modèle
m.find();
/*
* Tente de faire correspondre une séquence d'entrée commençant au début de la région avec ce modèle.
* L'auteur de Thinking in Java a sévèrement critiqué cette méthode car les mots ne permettent pas de savoir par où commencer la correspondance.
* Tout ce qui suit est vrai, car ils repartent de zéro à chaque fois
*/
m.lookingAt();
m.lookingAt();
m.lookingAt();
m.lookingAt();
9. Remplacement de chaîne
Copiez le code comme suit :
importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;
classe publique TestRegexReplacement {
public static void main (String[] arguments) {
Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//Le paramètre suivant est un entier, ce qui signifie "insensible à la casse"
Matcher m = p.matcher("Java java hxsyl Ilovejava java JaVaAcmer");
while(m.find()) {
System.out.println(m.group());//m.group affichera tout Java (en ignorant la casse)
}
String s = m.replaceAll("Java");//String a également cette méthode
System.out.println(s);
m.reset();//doit être ajouté car find et matcher s'influencent mutuellement
StringBuffer sb = new StringBuffer();
int je = 0;
/*
* La méthode suivante consiste à remplacer le nombre impair de java trouvé par "Java" et le nombre pair par "java"
*/
while(m.find()) {
je++;
//Il ne peut pas être écrit directement sous la forme i&1 et doit être converti en booléen
si((i&1)==1) {
m.appendReplacement(sb, "Java");
}autre {
m.appendReplacement(sb, "java");
}
}
m.appendTail(sb);//Ajouter la chaîne restante après le dernier java trouvé
System.out.println(sb);//Sans réinitialisation, seul Acmer est sorti
}
}
10. Regroupement
Copiez le code comme suit :
/*
* Ajoutez respectivement des parenthèses, sans compter l'accolade la plus extérieure, la première parenthèse gauche est le premier groupe
*/
Modèle p = Pattern.compile("(//d{3,5})([az]{2})");
Chaîne s = "123aaa-77878bb-646dd-00" ;
Matcher m = p.matcher(s);
while(m.find()) {
System.out.println(m.group());
System.out.println(m.group(1));//Afficher chaque paire de nombres correspondants
System.out.println(m.group(2));//Afficher chaque paire de lettres correspondantes
}
11. Capturez les e-mails des pages Web
Copiez le code comme suit :
importer java.io.BufferedReader ;
importer java.io.FileNotFoundException ;
importer java.io.FileReader ;
importer java.io.IOException ;
importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;
/*
* Si vous avez besoin d'une méthode de collecte, veuillez d'abord fournir le nom de la méthode.
* Ensuite, ctrl + 1 répertorie les recommandations et le système crée cette méthode
*/
classe publique EmailSpider {
public static void main (String[] arguments) {
// TODO Stub de méthode généré automatiquement
essayer {
BufferedReader br = new BufferedReader(new FileReader("F://regex.html"));
Ligne de chaîne = "" ;
essayer {
while((line=br.readLine())!=null) {
résoudre (ligne);
}
} catch (IOException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
résolution de vide statique privé (ligne de chaîne) {
// TODO Stub de méthode généré automatiquement
//Si l'expression régulière ne répond pas à la fonction correspondante, elle ne fera pas d'erreur car il s'agit d'une chaîne.
Modèle p = Pattern.compile("[//w[.-]]+@[//w[.-]]+//.[//w]+");
Matcher m = p.matcher(ligne);
while(m.find()) {
System.out.println(m.group());
}
}
}
12. Statistiques des codes
Copiez le code comme suit :
Voir le code
/*
* Comptez le nombre de lignes vides, de lignes de commentaires et de lignes de programme dans le code
* En fait, vous pouvez également utiliser StartWith et EndsWith dans String.
* S'il est utilisé par le chef de projet, il est également nécessaire de compter si le nombre de caractères dans chaque ligne se termine par { pour éviter la paresse.
*/
importer java.io.BufferedReader ;
importer java.io.File ;
importer java.io.FileNotFoundException ;
importer java.io.FileReader ;
importer java.io.IOException ;
classe publique CoderCount {
lignes normales longues statiques = 0 ;
commentLines longues statiques = 0 ;
lignes blanches longues statiques = 0 ;
public static void main (String[] arguments) {
Fichier f = nouveau fichier("D://share//src");
Fichier[] codeFiles = f.listFiles();
pour (Fichier enfant : codeFiles){
if(child.getName().matches(".*//.java$")) {
résoudre (enfant);
}
}
System.out.println("normalLines:" + normalLines);
System.out.println("commentLines:" + commentLines);
System.out.println("whiteLines:" + whiteLines);
}
résolution de vide statique privé (Fichier f) {
BufferedReader br = null ;
commentaire booléen = faux ;
essayer {
br = nouveau BufferedReader(nouveau FileReader(f));
Ligne de chaîne = "" ;
while((line = br.readLine()) != null) {
/*
* //Certaines lignes de commentaires ont un onglet devant elles
* ne peut pas être écrit après readLine
* La dernière ligne sera un pointeur nul
*/
line = line.trim();
//readLine supprime la nouvelle ligne après avoir lu la chaîne.
if(line.matches("^[//s&&[^//n]]*$")) {
lignes blanches++;
} else if (line.startsWith("/*") && !line.endsWith("*/")) {
commentLines++;
commentaire = vrai ;
} sinon if (line.startsWith("/*") && line.endsWith("*/")) {
commentLines++;
} else if (true == commentaire) {
commentLines++;
if(line.endsWith("*/")) {
commentaire = faux ;
}
} sinon if (line.startsWith("//")) {
commentLines++;
} autre {
lignesnormales++;
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} enfin {
si(br != nul) {
essayer {
br.close();
br = nul ;
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
13. Quantificateurs
inclure? *+ ; La valeur par défaut est Gourmand, ainsi que Réticent et Possessif (exclusif).
Copiez le code comme suit :
//Le regroupement est ajouté pour le voir plus clairement.
Modèle p = Pattern.compile("(.{3,10})+[0-9]");
Chaîne s = "aaaa5bbbb6";//La longueur est de 10
Matcher m = p.matcher(s);
/*
* Maintenant, sortie 0-10, la valeur par défaut est Greedy, avalez d'abord 10 caractères, constatez qu'ils ne correspondent pas, crachez-en un et constatez qu'ils correspondent ;
* Si Pattern.compile("(.{3,10}?)+[0-9]") devient réticent, alors il avalera d'abord trois caractères, trouvera une incompatibilité, continuera à avaler jusqu'à ce qu'il corresponde et affichera 0 à 5 ;
* Si Pattern.compile("(.{3,10}++)+[0-9]") est possessif (exclusif), il avale également 10 caractères en premier, mais ne les recrache pas, alors il ne correspondra pas ,
* Cette méthode est principalement utilisée lorsqu'une grande efficacité est requise (il y aura des erreurs).
*/
si(m.find()) {
System.out.println(m.start() + "----" + m.end());
}autre {
System.put.println("Ne correspond pas!");
}
14. Supplément (groupe non capturant)
Copiez le code comme suit :
//Le sens du groupe non capturant est opposé au sens littéral, ce qui signifie capturer s'il correspond
Modèle p = Pattern.compile("(?=a).{3}");
/*
* Sortie a66, ce qui équivaut à exiger qu'il commence par a. Vous pouvez également écrire Pattern.compile("[a].{2}");
* Si Pattern.compile(".{3}(?!=a)") ne se termine pas par un {2}[^a], mais que le caractère suivant n'est pas un (anticipation), 44a, 66b seront affichés, donc ceci Cet usage n'est pas couramment utilisé;
* S'il s'agit de Pattern.compile(".{3}(?=a)"), il affichera 444 (car ?=a est une anticipation. S'il est placé au premier plan, il sera inclus dans le groupe). , et s'il est placé à l'arrière, il ne sera pas inclus dans le groupe ;
*
*
*/
Chaîne s = "444a66b" ;
Matcher m = p.matcher(s);
while(m.find()) {
System.out.println(m.group());
}
15. Référence arrière
Copiez le code comme suit :
Modèle p = Modèle.compile("(//d//d)//1");
/*
* Output true, //1 signifie la même chose que le premier groupe, ce sera faux s'il est remplacé par 1213 ;
* S'il s'agit de Pattern.compile("(//d(//d))//2"), il doit être remplacé par 122.
*
*/
Chaîne s = "1212" ;
Matcher m = p.matcher(s);
System.out.println(m.matches());
16. Abréviation des drapeaux
"." ne correspond pas aux nouvelles lignes, rappelez-vous simplement CASE_INSENSITIVE, l'abréviation de "la correspondance insensible à la casse peut également être activée via l'expression d'indicateur intégrée (?i)".
