Inhaltsverzeichnis
Die Anleitung zu Java Reguläre Ausdrücke
View more Tutorials:
Ein Regelmäßiger Ausdruck (Regular expressions) definiert eine Vorlage (pattern) der Suche von der Kette. Sie ist benutzt, um eine Text zu suchen, ändern und bearbeiten. Die vom regelmäßigen Ausdruck definierte Vorlage können zu einer vorher gegebenen Text einmal oder vielmals passen oder nicht passen.
Die Abkürzung von dem regelmäßigen Ausdruck (regular expressions) is regex.
Die Abkürzung von dem regelmäßigen Ausdruck (regular expressions) is regex.
Die Regular Expression werden von den meisten Programmierungssprache unterstützt. Zum Beispiel sind das Java, C#, C/C++, usw... Leider unterstützt jede Sprache die Regular expression in ihrem eigenen unterschiedlichen Weg
Sie könnten die Interest daran haben:
No | Die regulären Ausdruck | Die Bezeichnung |
1 | . |
Irgendeinem Zeichen entsprechen (match) |
2 | ^regex |
Die reguläre Ausdruck muss bei der Startspunkt der Linie entsprechen |
3 | regex$ |
Die reguläre Ausdruck muss bei der Ende der Linie entsprechen |
4 | [abc] |
Die Definition einstellen, die a oder b oder c entsprechen. |
5 | [abc][vz] |
Die Definition einstellen, die a oder b oder c entsprechen, danach kommt v oder z. |
6 | [^abc] |
Wenn das Zeichen ^ als den ersten Charakter in eckige Klammer auftritt, verneint es das Modell. Das kann allen Zeicher außer a oder b oder c entsprechen |
7 | [a-d1-7] |
Der Raum: eine Buchstabe zwischen a und d und die Zahlen vom 1 bis 7 entsprechen |
8 | X|Z |
X oder Z finden |
9 | XZ |
X und folgend Z finden |
10 | $ |
Die Zeileende prüfen |
11 | \d |
Irgendeines Digit, für |
12 | \D |
Die nicht-Digit, für [^0-9] verküzen |
13 | \s |
Ein Leerzeichen, für [ \t\n\x0b\r\f] verküzen |
14 | \S |
Ein Nicht-Leerzeichen, für [^\s] verküzen |
15 | \w |
Eine Buchstabe, für [a-zA-Z_0-9] verküzen |
16 | \W |
Eine Nicht-Buchstabe, für [^\w] verküzen |
17 | \S+ |
Einige Nicht Leerzeichen (ein oder mehr) |
18 | \b |
Das zeichen vom a-z oder A-Z oder 0-9 oder _, für [a-zA-Z0-9_] verküzen. |
19 | * |
Zero oder mehrmals auftreten, für {0,} verküzen |
20 | + |
Eins oder mehrmals auftreten, für {1,} verküzen |
21 | ? |
Zero oder einsmal auftreten ? für {0,1} . verküzen |
22 | {X} |
X Mals auftreten {} |
23 | {X,Y} |
Vom X zum Y Mals auftreten |
24 | *? |
* bedeutet das Auftritt in zero oder mehrmals,? am hinter bedeutet die Suche nach der kleinste Übereinstimmung |
Einige besonderen Zeichen in Java Regex:
\.[{(*+?^$|
Die obengewähnten Zeichen sind die besonderen Zeichen. Im Java Regex: Wenn Sie diese besonderen Zeichen in dem normalen Weg verstehen möchten, brauchen Sie die Merkzeichen \ vor der Zeichen hinzufügen.
Zum Beispiel. die Zeichen Punkt (.) versteht java regex irgendeine Zeichen. Wenn Sie möchten, java regex versteht as eine normale Punkt, brauchen Sie die \ vor ihr hinzufügen.
Zum Beispiel. die Zeichen Punkt (.) versteht java regex irgendeine Zeichen. Wenn Sie möchten, java regex versteht as eine normale Punkt, brauchen Sie die \ vor ihr hinzufügen.
// Regex pattern describe any character. String regex = "."; // Regex pattern describe a dot character. String regex = "\\.";
- Class String
... // Check the entire String object matches the regex or not. public boolean matches(String regex) ..
Method String.matches(String regex) ermöglicht Ihnen zu checken, ob die alle String zu einer regex passen oder nicht. Das ist die üblichste Maßnahme. Sehen Sie die Beispiele
StringMatches.java
package org.o7planning.tutorial.regex.stringmatches; public class StringMatches { public static void main(String[] args) { String s1 = "a"; System.out.println("s1=" + s1); // Check the entire s1 // Match any character // Rule . // ==> true boolean match = s1.matches("."); System.out.println("-Match . " + match); s1 = "abc"; System.out.println("s1=" + s1); // Check the entire s1 // Match any character // Rule . // ==> false (Because s1 has three characters) match = s1.matches("."); System.out.println("-Match . " + match); // Check the entire s1 // Match with any character 0 or more times // Combine the rules . and * // ==> true match = s1.matches(".*"); System.out.println("-Match .* " + match); String s2 = "m"; System.out.println("s2=" + s2); // Check the entire s2 // Start by m // Rule ^ // ==> true match = s2.matches("^m"); System.out.println("-Match ^m " + match); s2 = "mnp"; System.out.println("s2=" + s2); // Check the entire s2 // Start by m // Rule ^ // ==> false (Because s2 has three characters) match = s2.matches("^m"); System.out.println("-Match ^m " + match); // Start by m // Next any character, appearing one or more times. // Rule ^ and. and + // ==> true match = s2.matches("^m.+"); System.out.println("-Match ^m.+ " + match); String s3 = "p"; System.out.println("s3=" + s3); // Check s3 ending with p // Rule $ // ==> true match = s3.matches("p$"); System.out.println("-Match p$ " + match); s3 = "2nnp"; System.out.println("s3=" + s3); // Check the entire s3 // End of p // ==> false (Because s3 has 4 characters) match = s3.matches("p$"); System.out.println("-Match p$ " + match); // Check out the entire s3 // Any character appearing once. // Followed by n, appear one or up to three times. // End by p: p $ // Combine the rules: . , {X, y}, $ // ==> true match = s3.matches(".n{1,3}p$"); System.out.println("-Match .n{1,3}p$ " + match); String s4 = "2ybcd"; System.out.println("s4=" + s4); // Start by 2 // Next x or y or z // Followed by any one or more times. // Combine the rules: [abc]. , + // ==> true match = s4.matches("2[xyz].+"); System.out.println("-Match 2[xyz].+ " + match); String s5 = "2bkbv"; // Start any one or more times // Followed by a or b, or c: [abc] // Next z or v: [zv] // Followed by any // ==> true match = s5.matches(".+[abc][zv].*"); System.out.println("-Match .+[abc][zv].* " + match); } }
Das Ergebnis von dem Beispiel

SplitWithRegex.java
package org.o7planning.tutorial.regex.stringmatches; public class SplitWithRegex { public static final String TEXT = "This is my text"; public static void main(String[] args) { System.out.println("TEXT=" + TEXT); // White space appears one or more times. // The whitespace characters: \t \n \x0b \r \f // Combining rules: \ s and + String regex = "\\s+"; String[] splitString = TEXT.split(regex); // 4 System.out.println(splitString.length); for (String string : splitString) { System.out.println(string); } // Replace all whitespace with tabs String newText = TEXT.replaceAll("\\s+", "\t"); System.out.println("New text=" + newText); } }
Das Ergebnis von dem Beispiel

EitherOrCheck.java
package org.o7planning.tutorial.regex.stringmatches; public class EitherOrCheck { public static void main(String[] args) { String s = "The film Tom and Jerry!"; // Check the whole s // Begin by any characters appear 0 or more times // Next Tom or Jerry // End with any characters appear 0 or more times // Combine the rules:., *, X | Z // ==> true boolean match = s.matches(".*(Tom|Jerry).*"); System.out.println("s=" + s); System.out.println("-Match .*(Tom|Jerry).* " + match); s = "The cat"; // ==> false match = s.matches(".*(Tom|Jerry).*"); System.out.println("s=" + s); System.out.println("-Match .*(Tom|Jerry).* " + match); s = "The Tom cat"; // ==> true match = s.matches(".*(Tom|Jerry).*"); System.out.println("s=" + s); System.out.println("-Match .*(Tom|Jerry).* " + match); } }
Das Ergebni von dem Beispiel

1. Pattern ist ein Vorlage Objekt, eine aus der regular expression kompilierte Version. Es hat keine public Constructor und wir benutzen eine static method compile(String) um einen Objekt zu erstellen ( der Parameter ist die regular expression).
2. Matcher ist ein Mittel zu checken, ob die Input Datenreihe zum oben erstellten Objekt Pattern passt oder nicht. Diese Class hat keine public constructor. Und wir nehmen diesen Objejt durch die method matcher(String) des Objekt Pattern. Und der Eingabeparameter String ist die Text, die ist zu checken
3.PatternSyntaxException wird geworfen wenn die regular expression nicht genau ist.
2. Matcher ist ein Mittel zu checken, ob die Input Datenreihe zum oben erstellten Objekt Pattern passt oder nicht. Diese Class hat keine public constructor. Und wir nehmen diesen Objejt durch die method matcher(String) des Objekt Pattern. Und der Eingabeparameter String ist die Text, die ist zu checken
3.PatternSyntaxException wird geworfen wenn die regular expression nicht genau ist.
String regex= ".xx."; // Create a Pattern object through a static method. Pattern pattern = Pattern.compile(regex); // Get a Matcher object Matcher matcher = pattern.matcher("MxxY"); boolean match = matcher.matches(); System.out.println("Match "+ match);
- Class Pattern:
public static Pattern compile(String regex, int flags) ; public static Pattern compile(String regex); public Matcher matcher(CharSequence input); public static boolean matches(String regex, CharSequence input);
- Class Matcher:
public int start() public int start(int group) public int end() public int end(int group) public String group() public String group(int group) public String group(String name) public int groupCount() public boolean matches() public boolean lookingAt() public boolean find()
Das ist ein Beispiel für die Benutzung Matcher und die Method find(), um die untergeordneten Kette zu finden, die zu einer regular expression passen

MatcherFind.java
package org.o7planning.tutorial.regex; import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherFind { public static void main(String[] args) { final String TEXT = "This \t is a \t\t\t String"; // Spaces appears one or more time. String regex = "\\s+"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(TEXT); int i = 0; while (matcher.find()) { System.out.print("start" + i + " = " + matcher.start()); System.out.print(" end" + i + " = " + matcher.end()); System.out.println(" group" + i + " = " + matcher.group()); i++; } } }
Das Ergebnis vom Beispiel

Method Matcher.lookingAt()
MatcherLookingAt.java
package org.o7planning.tutorial.regex; import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherLookingAt { public static void main(String[] args) { String country1 = "iran"; String country2 = "Iraq"; // Start by I followed by any character. // Following is the letter a or e. String regex = "^I.[ae]"; Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE); Matcher matcher = pattern.matcher(country1); // lookingAt () searches that match the first part. System.out.println("lookingAt = " + matcher.lookingAt()); // matches() must be matching the entire System.out.println("matches = " + matcher.matches()); // Reset matcher with new text: country2 matcher.reset(country2); System.out.println("lookingAt = " + matcher.lookingAt()); System.out.println("matches = " + matcher.matches()); } }
Eine Regular Expression können Sie in die Gruppe trennen (group):
// A regular expression String regex = "\\s+=\\d+"; // Writing as three group, by marking () String regex2 = "(\\s+)(=)(\\d+)"; // Two group String regex3 = "(\\s+)(=\\d+)";
Die Gruppe können miteinander einnisten. Deshalb brauchen wir eine Regelung um die Index der Gruppe zu markieren. Alle Pattern werden als die Gruppe 0 definiert. Und die restlichen Gruppe werden wie in die folgenden Illustration bezeichnet

Beachten Sie: (?:pattern) benutzen, um Java eine None-capturing group zu informieren
Ab Java 7 können Sie eine Gruppe mit einem Name bestimmen (?<name>pattern), Und Sie können die Inhalte zugreifen, die zu Matcher.group(String name) passen. Das macht Regex länger aber die Code ist sinnvoller und einfacher
Die Gruppe nach dem Name kann durch Matcher.group(int group) mit der ähnlichen Index zugegriffen werden.
Java bildet nur vom Name zur Index der Gruppe ab. Deshalb können Sie den gleichen Name für 2 unterschiedliche Gruppen nicht benutzen
Die Gruppe nach dem Name kann durch Matcher.group(int group) mit der ähnlichen Index zugegriffen werden.
Java bildet nur vom Name zur Index der Gruppe ab. Deshalb können Sie den gleichen Name für 2 unterschiedliche Gruppen nicht benutzen
-
Sehen Sie ein Beispiel über die Stellung des Name für die Gruppe (Java >=7)
NamedGroup.java
package org.o7planning.tutorial.regex; import java.util.regex.Matcher; import java.util.regex.Pattern; public class NamedGroup { public static void main(String[] args) { final String TEXT = " int a = 100;float b= 130;float c= 110 ; "; // Use (?<groupName>pattern) to define a group named: groupName // Defined group named declare: using (?<declare>...) // And a group named value: use: (?<value>..) String regex = "(?<declare>\\s*(int|float)\\s+[a-z]\\s*)=(?<value>\\s*\\d+\\s*);"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(TEXT); while (matcher.find()) { String group = matcher.group(); System.out.println(group); System.out.println("declare: " + matcher.group("declare")); System.out.println("value: " + matcher.group("value")); System.out.println("------------------------------"); } } }
Das Ergebnis von dem Beispiel:

Sie können die Image wie folgend sehen

In einigen Fälle ist *? sehr wichtig. Sehen Sie ein Beispiel:
// This is a regex // any characters appear 0 or more times, // followed by ' and > String regex = ".*'>"; // TEXT1 match the regex. String TEXT1 = "FILE1'>"; // And TEXT2 match the regex String TEXT2 = "FILE1'> <a href='http://HOST/file/FILE2'>";

*? wird einen kleinsten Zusammenklang finden. Sehen wir das folgende Beispiel:
NamedGroup2.java
package org.o7planning.tutorial.regex; import java.util.regex.Matcher; import java.util.regex.Pattern; public class NamedGroup2 { public static void main(String[] args) { String TEXT = "<a href='http://HOST/file/FILE1'>File 1</a>" + "<a href='http://HOST/file/FILE2'>File 2</a>"; // Java >= 7. // Define group named fileName. // *? ==> ? after a quantifier makes it a reluctant quantifier. // It tries to find the smallest match. String regex = "/file/(?<fileName>.*?)'>"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(TEXT); while (matcher.find()) { System.out.println("File Name = " + matcher.group("fileName")); } } }
Das Ergebnis von dem Beispiel
