1. Regex (regulärer Ausdruck): RegularExpressions (ersetzt StringTokenizer); ein leistungsstarkes Tool für die String-Verarbeitung; Perl eignet sich sogar noch besser für die Verwendung von Regex.
Wird hauptsächlich beim String-Matching, Suchen und Ersetzen verwendet. Beispiel: Der Abgleich von IP-Adressen (Bereich unter 256) ist mit regulären Ausdrücken einfach zu verwenden; das Extrahieren einer großen Anzahl von E-Mail-Adressen aus Webseiten zum Versenden von Spam; Enthält Matcher (das Ergebnis des Abgleichs einer Zeichenfolge mit einem Muster) und Muster.
Kopieren Sie den Codecode wie folgt:
/*
* Gibt an, ob dieser String mit dem angegebenen regulären Ausdruck (auch ein String) übereinstimmt.
*/
System.out.println("abc".matches("..."));//Jedes "." stellt ein Zeichen dar
Kopieren Sie den Codecode wie folgt:
/*
* Ersetzen Sie alle Zahlen in der Zeichenfolge durch „-“. Die normale Methode erfordert, dass charAt einzeln beurteilt wird.
* „//d“ stellt eine beliebige Zahl dar oder ersetzt sie durch „[0-9]“;
* „//D“ steht für eine beliebige Nicht-Ziffer oder wird durch „[^0-9]“ ersetzt.
*/
System.out.println("ab54564654sbg48746bshj".replaceAll("[0-9]", "-"));//Jedes "." stellt ein Zeichen dar
zwei,
Kopieren Sie den Codecode wie folgt:
/*
* kompilieren kompiliert den angegebenen regulären Ausdruck in das Muster (jede Kompilierung benötigt Zeit); {3} bedeutet genau dreimal.
* X{n} X, genau n-mal
* X{n,} X, mindestens n-mal
* X{n,m} X, mindestens n-mal, aber nicht mehr als m-mal
*/
Muster p = Pattern.compile("[az]{3}");
Matcher m = p.matcher("ggs");//Erstelle einen Matcher, der die gegebene Eingabe mit diesem Muster übereinstimmt. Intern wird tatsächlich ein Prioritätszustandsautomat erstellt (Kompilierungsprinzip)
// Die in Matcher und Matches abzugleichende Zeichenfolge ist eigentlich CharSequence (Schnittstelle), aber String implementiert diese Schnittstelle und weist Polymorphismus auf
System.out.println(m.matches());//Wenn es „ggss“ ist, wird es nicht übereinstimmen
//Sie können immer direkt „ggs“.matches(“[az]{3}“) verwenden, aber das oben Genannte hat Vorteile, zumindest ist es effizienter und Pattern und Matcher bieten viele Funktionen
3. Rufen Sie das Metazeichen im regulären Ausdruck auf: „. * +“; Strg + Umschalt + „/“ bedeutet Kommentar, ersetzen Sie es durch „/“, um den Kommentar zu entfernen.
Kopieren Sie den Codecode wie folgt:
„a“.matches(“.“);//true, „.“ steht für jedes Zeichen, einschließlich chinesischer Zeichen
"aa".matches("aa");//true, das heißt, normale Zeichenfolgen können auch als reguläre Ausdrücke verwendet werden
/*
* wahr, „*“ bedeutet 0 oder mehr Zeichen, aber die folgenden Zeichen müssen mit dem ersten identisch sein.
* Andernfalls ist es falsch, das heißt, es wird beurteilt, ob es sich bei der Zeichenfolge um eine Zeichenfolge handelt, die aus einzelnen Zeichen besteht.
*/
"aaaa".matches("a*");
"".matches("a*");//true
"aaa".matches("a?");//true, einmal oder 0 Mal
"".matches("a?");//true
"a".matches("a?");//true
"544848154564113".matches("//d{3,100}");//true
//Dies ist das einfachste IP-Urteil, aber wenn es 255 überschreitet, kann es nicht beurteilt werden.
"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] bedeutet, dass ein beliebiges Zeichen übereinstimmt; [^abc] bedeutet ein anderes Zeichen als abc (muss immer noch ein Buchstabe sein, und false wird zurückgegeben, wenn es eine leere Zeichenfolge ist); „[az ]|[AZ]“ ist ein bestimmter Groß- oder Kleinbuchstabe; [AZ&&[ABS]] bedeutet einen der Großbuchstaben und ABS.
Kopieren Sie den Codecode wie folgt:
//Ich habe festgestellt, dass es keinen Unterschied zwischen |. und || gibt, aber es gibt einen Unterschied zwischen & und &&. Ich weiß nicht, ob das der richtige Weg ist, das zu verstehen.
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. /w Wortzeichen: [a-zA-Z_0-9] beim Abgleichen von Benutzernamen; /s Leerzeichen: [ /t/n/x0B/f/r]; ] ;/W Nicht-Wort-Zeichen: [^/w].
Kopieren Sie den Codecode wie folgt:
" /n/t/r".matches("//s{4}");//true
" ".matches("//S");//false
"a_8".matches("//w{3}");//true
//"+" bedeutet einmal oder mehrmals
"abc888&^%".matches("[az]{1,3}//d+[&^#%]+");//true
/*
* Das abzugleichende Zeichen ist nur ein Backslash, kann aber nicht als „/“ geschrieben und dann mit dem folgenden „/“ kombiniert werden.
* Das vorherige „kann nicht übereinstimmen“ führt zu CE.
Auf * darf kein „//“ folgen, da sonst ein Laufzeitfehler auftritt (kein Problem bei der Kompilierung), es muss als „////“ geschrieben werden.
*/
System.out.println("//".matches("////"));//true
6. POSIX-Zeichenklasse (nur US-ASCII)
Kopieren Sie den Codecode wie folgt:
/p{Lower} Alphabetische Kleinbuchstaben: [az] ;/p{Upper} Alphabetische Großbuchstaben: [AZ] ;/p{ASCII} Alle ASCII: [/x00-/x7F] ;/p{Alpha} Alphabetische Zeichen: [/p{Lower}/p{Upper}] ;/p{Digit} Dezimalzahl: [0-9].
7. Grenzabgleicher
^ Anfang der Zeile $ Ende der Zeile/b Wortgrenze/B Nicht-Wortgrenze/A Anfang der Eingabe/G Ende der vorherigen Übereinstimmung/Z Ende der Eingabe, wird nur für das letzte Abschlusszeichen verwendet (falls vorhanden)
/z Ende der Eingabe
Kopieren Sie den Codecode wie folgt:
"hello world".matches("^h.*");//Der Anfang der ^-Zeile
"hello world".matches(".*ld$");//Ende der $-Zeile
"hello world".matches("^h[az]{1,3}o//b.*");///bWortgrenze
"helloworld".matches("^h[az]{1,3}o//b.*");
" /n".matches("^[//s&&[^//n]]*//n$");//Leerzeilen beurteilen, die mit einem Leerzeichen beginnen
8. Sie können auch m.start() und m.end() unter der Suchmethode verwenden, um die nächste Position zwischen der Startposition und der Endposition zurückzugeben. Wenn sie nicht gefunden werden kann, tritt ein Fehler auf.
Kopieren Sie den Codecode wie folgt:
Muster p = Pattern.compile("//d{3,5}");
Zeichenfolge s = "133-34444-333-00";
Matcher m = p.matcher(s);
m.matches();//matches stimmt mit allen Zeichenfolgen überein
m.reset();
/*
* Wenn unten zuerst die Reset-Methode aufgerufen wird, wird true, true, true, false ausgegeben.
* Andernfalls gibt der vorletzte Fund ebenfalls false aus.
*Die Gründe sind wie folgt:
* entspricht dem ersten „-“ und stellt fest, dass es nicht übereinstimmt, aber diese vier Zeichen wurden gefressen. Der Abgleich beginnt erneut
* 34444 beginnt und die zweite Suche beginnt bei 333, da die Suche mit der nächsten Teilsequenz übereinstimmt.
* Mit der Reset-Methode können Matches die von Matches gefressene Zeichenfolge ausspucken.
* Zusammenfassend: Reset muss zwischen Matches und Find verwendet werden, da sie sich gegenseitig beeinflussen
*
*/
m.find();
m.find();
m.find();//Versuchen Sie, die nächste Teilsequenz der Eingabesequenz zu finden, die diesem Muster entspricht
m.find();
/*
* Versucht, eine Eingabesequenz beginnend am Anfang der Region mit diesem Muster abzugleichen.
* Der Autor von Thinking in Java hat diese Methode heftig kritisiert, da aus den Wörtern nicht klar hervorgeht, wo mit dem Matching begonnen werden soll.
* Alle folgenden Aussagen sind wahr, da sie jedes Mal von vorne beginnen
*/
m.lookingAt();
m.lookingAt();
m.lookingAt();
m.lookingAt();
9. Saitenaustausch
Kopieren Sie den Codecode wie folgt:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
öffentliche Klasse TestRegexReplacement {
public static void main(String[] args) {
Muster p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//Der folgende Parameter ist eine Ganzzahl, was bedeutet, dass die Groß- und Kleinschreibung nicht berücksichtigt wird.
Matcher m = p.matcher("Java java hxsyl Ilovejava java JaVaAcmer");
while(m.find()) {
System.out.println(m.group());//m.group gibt alles Java aus (Groß- und Kleinschreibung wird ignoriert)
}
String s = m.replaceAll("Java");//String hat auch diese Methode
System.out.println(s);
m.reset();//muss hinzugefügt werden, da find und matcher sich gegenseitig beeinflussen
StringBuffer sb = new StringBuffer();
int i = 0;
/*
* Die folgende Methode besteht darin, die ungerade Anzahl der gefundenen Javas durch „Java“ und die geraden Zahlen durch „Java“ zu ersetzen.
*/
while(m.find()) {
i++;
//Es kann nicht direkt als i&1 geschrieben werden und muss in einen booleschen Wert konvertiert werden
if((i&1)==1) {
m.appendReplacement(sb, "Java");
}anders {
m.appendReplacement(sb, "java");
}
}
m.appendTail(sb);// Fügen Sie die verbleibende Zeichenfolge nach dem letzten gefundenen Java hinzu
System.out.println(sb);//Ohne Reset wird nur Acmer ausgegeben
}
}
10. Gruppierung
Kopieren Sie den Codecode wie folgt:
/*
* Fügen Sie jeweils Klammern hinzu, wobei die äußerste Klammer nicht mitgezählt wird. Die erste linke Klammer ist die erste Gruppe
*/
Muster p = Pattern.compile("(//d{3,5})([az]{2})");
String s = "123aaa-77878bb-646dd-00";
Matcher m = p.matcher(s);
while(m.find()) {
System.out.println(m.group());
System.out.println(m.group(1));//Jedes Paar übereinstimmender Zahlen ausgeben
System.out.println(m.group(2));//Jedes Paar passender Buchstaben ausgeben
}
11. Erfassen Sie E-Mails von Webseiten
Kopieren Sie den Codecode wie folgt:
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
* Wenn Sie eine Erhöhungsmethode benötigen, geben Sie bitte zuerst den Methodennamen an.
* Dann listet Strg + 1 Empfehlungen auf und das System erstellt diese Methode
*/
öffentliche Klasse EmailSpider {
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
versuchen {
BufferedReader br = new BufferedReader(new FileReader("F://regex.html"));
String line = "";
versuchen {
while((line=br.readLine())!=null) {
lösen(Zeile);
}
} Catch (IOException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
} Catch (FileNotFoundException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
private static void lösen(String line) {
// TODO Automatisch generierter Methoden-Stub
//Wenn der reguläre Ausdruck die entsprechende Funktion nicht erfüllt, wird kein Fehler ausgegeben, da es sich um eine Zeichenfolge handelt.
Muster p = Pattern.compile("[//w[.-]]+@[//w[.-]]+//.[//w]+");
Matcher m = p.matcher(line);
while(m.find()) {
System.out.println(m.group());
}
}
}
12. Codestatistiken
Kopieren Sie den Codecode wie folgt:
Code anzeigen
/*
* Zählen Sie die Anzahl der Leerzeilen, Kommentarzeilen und Programmzeilen im Code
* Tatsächlich können Sie auch „startsWith“ und „endsWith“ in String verwenden.
* Bei Verwendung durch den Projektmanager muss auch gezählt werden, ob die Anzahl der Zeichen in jeder Zeile mit { endet
*/
import java.io.BufferedReader;
java.io.File importieren;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
öffentliche Klasse CoderCount {
static long normalLines = 0;
static long commentLines = 0;
static long whiteLines = 0;
public static void main(String[] args) {
Datei f = neue Datei("D://share//src");
File[] codeFiles = f.listFiles();
for(Untergeordnete Datei: codeFiles){
if(child.getName().matches(".*//.java$")) {
lösen(Kind);
}
}
System.out.println("normalLines:" + normalLines);
System.out.println("commentLines:" + commentLines);
System.out.println("whiteLines:" + whiteLines);
}
private static void lösen(Datei f) {
BufferedReader br = null;
boolescher Kommentar = false;
versuchen {
br = new BufferedReader(new FileReader(f));
String line = "";
while((line = br.readLine()) != null) {
/*
* //Einige Kommentarzeilen haben ein Tabulatorzeichen davor
* kann nicht nach readLine geschrieben werden
* Die letzte Zeile ist ein Nullzeiger
*/
line = line.trim();
//readLine entfernt die neue Zeile nach dem Lesen der Zeichenfolge.
if(line.matches("^[//s&&[^//n]]*$")) {
whiteLines++;
} else if (line.startsWith("/*") && !line.endsWith("*/")) {
commentLines++;
Kommentar = wahr;
} else if (line.startsWith("/*") && line.endsWith("*/")) {
commentLines++;
} else if (true == comment) {
commentLines++;
if(line.endsWith("*/")) {
Kommentar = false;
}
} else if (line.startsWith("//")) {
commentLines++;
} anders {
normalLines++;
}
}
} Catch (FileNotFoundException e) {
e.printStackTrace();
} Catch (IOException e) {
e.printStackTrace();
} Endlich {
if(br != null) {
versuchen {
br.close();
br = null;
} Catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
13. Quantifizierer
enthalten? *+; Die Standardeinstellung ist Greedy sowie Reluctant und Possessive (exklusiv).
Kopieren Sie den Codecode wie folgt:
//Die Gruppierung wird hinzugefügt, um sie klarer zu sehen.
Muster p = Pattern.compile("(.{3,10})+[0-9]");
String s = "aaaa5bbbb6";//Die Länge beträgt 10
Matcher m = p.matcher(s);
/*
* Geben Sie jetzt 0-10 aus, der Standardwert ist Greedy. Verschlucken Sie zuerst 10 Zeichen, stellen Sie fest, dass sie nicht übereinstimmen, spucken Sie eines aus und stellen Sie fest, dass sie übereinstimmen.
* Wenn Pattern.compile("(.{3,10}?)+[0-9]") zu einem Reluctant wird, verschluckt es zuerst drei Zeichen, findet eine Nichtübereinstimmung, schluckt weiter, bis es übereinstimmt, und gibt 0 aus bis 5;
* Wenn Pattern.compile("(.{3,10}++)+[0-9]") Possessiv (exklusiv) ist, verschluckt es zunächst auch 10 Zeichen, spuckt sie aber nicht aus, dann wird es nicht abgeglichen ,
* Diese Methode wird hauptsächlich dort eingesetzt, wo eine hohe Effizienz erforderlich ist (es treten Fehler auf).
*/
if(m.find()) {
System.out.println(m.start() + „----“ + m.end());
}anders {
System.put.println("Keine Übereinstimmung!");
}
14. Ergänzung (nicht erfassende Gruppe)
Kopieren Sie den Codecode wie folgt:
// Die Bedeutung der nicht erfassenden Gruppe ist das Gegenteil der wörtlichen Bedeutung, was bedeutet, dass sie erfasst wird, wenn sie übereinstimmt
Muster p = Pattern.compile("(?=a).{3}");
/*
* Geben Sie a66 aus, was der Anforderung entspricht, mit a zu beginnen. Sie können auch Pattern.compile("[a].{2}"); schreiben.
* Wenn Pattern.compile(".{3}(?!=a)") nicht mit einem {2}[^a] endet, das nächste Zeichen jedoch kein (Lookahead) ist, werden 44a, 66b ausgegeben. also das Diese Verwendung wird nicht häufig verwendet;
* Wenn es Pattern.compile(".{3}(?=a)") ist, wird 444 ausgegeben (da ?=a ein Lookahead ist, wird es in die Gruppe aufgenommen). , und wenn es hinten platziert wird, wird es nicht in die Gruppe aufgenommen;
*
*
*/
Zeichenfolge s = "444a66b";
Matcher m = p.matcher(s);
while(m.find()) {
System.out.println(m.group());
}
15. Rückverweis
Kopieren Sie den Codecode wie folgt:
Muster p = Pattern.compile("(//d//d)//1");
/*
* Ausgabe wahr, // 1 bedeutet dasselbe wie die erste Gruppe. Wenn es in 1213 geändert wird, ist es falsch.
* Wenn es Pattern.compile("(//d(//d))//2") ist, muss es in 122 geändert werden.
*
*/
Zeichenfolge s = "1212";
Matcher m = p.matcher(s);
System.out.println(m.matches());
16. Abkürzung der Flaggen
„.“ stimmt nicht mit Zeilenumbrüchen überein, denken Sie nur an CASE_INSENSITIVE, die Abkürzung für „Groß-/Kleinschreibung kann auch durch den eingebetteten Flag-Ausdruck (?i) aktiviert werden“.
