Wie wir alle wissen, ist es in der Programmentwicklung unvermeidlich, Situationen zu begegnen, in denen Saiten übereinstimmen, gesucht, ersetzt und beurteilt werden müssen. Diese Situationen sind manchmal komplizierter. Wenn es in reiner Codierung gelöst wird, verschwendet es oft Zeit und Energie der Programmierer. Daher sind das Lernen und die Verwendung regulärer Ausdrücke das Hauptmittel zur Lösung dieses Widerspruchs geworden.
Wie wir alle wissen, sind regelmäßige Ausdrücke eine Spezifikation, die für das Musteranpassung und für den Austausch verwendet werden kann. Ein regulärer Ausdruck ist ein wörtliches Muster, das aus gewöhnlichen Zeichen (wie Zeichen A bis Z) und Sonderzeichen (Metacharacter) besteht. Es wird verwendet, um eine oder mehrere Strings zu beschreiben, die bei der Suche nach dem Körper eines wörtlichen Suchens übereinstimmen sollen. Der reguläre Ausdruck fungiert als Vorlage für ein Zeichenmuster mit der durchsuchten Zeichenfolge.
Seit JDK1.4 das Paket java.util.regex gestartet hat, hat es uns eine gute Java -Anwendungsplattform für die Anwendung von Java zur Verfügung gestellt.
Da reguläre Ausdrücke ein sehr komplexes System sind, werde ich nur einige Beispiele für Einführungskonzepte angeben. Weitere Informationen finden Sie in verwandten Büchern und erkunden Sie sie selbst.
// Backslash
/t Intervall ('/u0009')
/n Zeilenpause ('/u000a')
/r eingereicht ('/u000d')
/D-Nummer entspricht [0-9]
/D Nicht-Digit entspricht [^0-9]
/s leeres Symbol [/t/n/x0b/f/r]
/S Nicht-Blank-Symbol [^/t/n/x0b/f/r]
/w Individuelle Zeichen [A-Za-Z_0-9]
/W nicht-individuelle Zeichen [^a-za-z_0-9]
/f Seitenpause
/e entkommen
/b die Grenze eines Wortes
/B a Nicht-Wort-Grenze
/G Ende des vorherigen Spiels
^ beginnt mit Limit
^Java -Bedingungsgrenze ist für Zeichen, die mit Java beginnen
$ ist das Ende der Grenze
Java $ Condition Limit sind Java-End-Charaktere
. Bedingte Grenzen jedes einzelne Zeichen außer /n
Java .. Nach der Bedingungsgrenze ist Java, zwei Zeichen mit Ausnahme der Newline
Fügen Sie spezifische Einschränkungen hinzu "[]"
[AZ] Die Bedingungen sind auf einen Charakter im Kleinbuchstaben A bis Z -Bereich beschränkt
[AZ] Die Bedingungen sind auf einen Charakter im Großbuchstaben A bis Z -Bereich beschränkt
[a-za-z] Die Bedingungen sind auf einen Charakter im Kleinbuchstaben A bis Z oder Großbuchstaben A bis Z beschränkt
Die Bedingungen sind auf einen Zeichen im Bereich von Kleinbuchstaben 0 bis 9 beschränkt
Die Bedingungen sind auf Kleinbuchstaben 0 bis 9 oder A bis Z-Bereich begrenzt
[0-9 [AZ]] Die Bedingungen sind auf Kleinbuchstaben von 0 bis 9 oder A bis Z (Kreuzung) begrenzt (Kreuzung)
[] und fügen Sie die Einschränkungsbedingung hinzu "[^]" erneut
[^az] Die Bedingungen beschränken sich auf einen Charakter im Bereich von Nicht-Unterwasser A bis Z.
[^Az] Bedingung begrenzt ein Zeichen in den Nichtkapseln A bis Z-Bereich
[^a-za-z] Die Bedingungen sind auf einen Charakter im Bereich von Nicht-Unterkünften a bis z oder Großbuchstaben a bis z beschränkt
[^0-9] Die Bedingungen sind auf einen Charakter im Bereich von Nicht-Unterkünften 0 bis 9 beschränkt
[^0-9a-z] Die Bedingungen sind auf einen Charakter im Bereich von Nicht-Unterkünften von 0 bis 9 oder a bis z beschränkt
[^0-9 [AZ]] Die Bedingungen sind auf einen Charakter im Bereich von Nicht-Unterkünften von 0 bis 9 oder A bis Z beschränkt (Kreuzung)
Wenn die Einschränkungsbedingung lautet, dass ein bestimmtes Zeichen mehr als 0 Mal erscheint, können Sie "*" verwenden.
J* mehr als 0 j
.* Jeder Zeichen über 0
J.*DJ und D alle 0 Zeichen
Wenn die Einschränkungsbedingung lautet, dass ein bestimmtes Zeichen mehr als einmal erscheint, können Sie "+" verwenden.
J+ 1 oder mehr j J.
.+ 1 oder mehr willkürliche Zeichen
J.+1 oder mehr Charakter zwischen DJ und D.
Wenn die Einschränkungsbedingung ist, dass ein bestimmtes Zeichen 0 oder öfter Male erscheint, "?" kann verwendet werden.
Ja? J oder Ja erscheint
Grenze auf das kontinuierliche Auftreten des angegebenen Zahlenzeichens "{a}"
J {2} jj
J {3} JJJ
Mehr als ein Text und "{a,}"
J {3,} jjj, jjjjj, jjjjj, ??? (j koexistiere mehr als dreimal)
Mehr als ein Text, weniger als B "{a, b}"
J {3,5} jjj oder jjjj oder jjjjjjjjjj
Nimm einen der beiden
J | aj oder a
Java | Hallo Java oder Hallo
"()" gibt einen Kombinationstyp an, beispielsweise, wenn ich die Daten zwischen <a href =/"index.html/"> index </a> abfragen kann <a.*href =/".*/"> (.+?) </a> </a>
Wenn Sie die Funktion muster.comPile verwenden, können Sie Parameter hinzufügen, die das Übereinstimmungsverhalten regulärer Ausdrücke steuern:
Muster muster.comPile (String Regex, int Flag)
Der Wertebereich von Flags ist wie folgt:
Muster.canon_eq Die Übereinstimmung wird nur dann bestimmt, wenn die "kanonische Zerlegung" der beiden Zeichen genau gleich ist. Nachdem der Ausdruck "A/U030A" "übereinstimmen"? " Standardmäßig wird "kanonische Gleichheit" nicht berücksichtigt.
Muster.case_inemsitiv (? I) standardmäßig ist eine von Fall nicht identifizierte Matching nur für US-ACTII-Zeichensätze verfügbar. Mit dieser Flagge können Ausdrücke den Fall für die Übereinstimmung ignorieren. Um Unicode -Zeichen mit unbekannter Größe anzupassen, kombinieren Sie einfach Unicode_Case mit diesem Flag.
Muster.comments (? X) In diesem Modus werden die Speicherzeichen (in regulären Ausdrücken) beim Übereinstimmung (Anmerkung des Übersetzers: Bezieht sich nicht auf "// s" im Ausdruck, bezieht sich jedoch auf Räume, Registerkarten, Wagenrendite usw.) im Ausdruck. Kommentare beginnen bei # und enden in dieser Zeile. Der UNIX -Zeilenmodus kann durch eingebettete Flags aktiviert werden.
Muster.dotall (& s) in diesem Modus, der Ausdruck '.' kann jedem Charakter übereinstimmen, einschließlich des Endcharakters, der eine Zeile darstellt. Standardmäßig der Ausdruck '.' stimmt nicht mit dem Endcharakter der Linie überein.
Muster.Multilin
(? M) In diesem Modus stimmen '^' und '$' mit dem Beginn und Ende einer Reihe überein. Zusätzlich stimmt '^' immer noch mit dem Beginn der Zeichenfolge überein, und '$' entspricht auch dem Ende der Zeichenfolge. Standardmäßig stimmen diese beiden Ausdrücke nur mit dem Anfang und Ende der Zeichenfolge überein.
Muster.unicode_case
(u) In diesem Modus werden die Unicode -Zeichen mit nicht identifiziertem Fall übereinstimmen, wenn Sie auch das Case_inemsitive -Flag aktivieren. Standardmäßig ist eine unempfindliche Übereinstimmung für die US-ACTII-Zeichensätze nur für die Sets von US-Ascii verfügbar.
Muster.unix_lines (? D) In diesem Modus gilt nur '/n' als Abbruch einer Zeile und Übereinstimmungen '.', '^' Und '$'.
Abgesehen von dem leeren Konzept finden Sie hier einige einfache reguläre Java -Anwendungsfälle:
◆ Zum Beispiel, wenn die String überprüft wird
// eine Zeichenfolge finde, die mit Java beginnt und bei Will muster muster muster.must.comPile ("^java.*"); Matcher Matcher = muster.Matcher ("Java ist kein Mensch"); boolean b = Matcher.Matches (); // Wenn die Bedingung erfüllt ist, gibt sie wahr, ansonsten falsches System.out.println (b); ◆ Beim Spalten von Zeichenfolgen mit mehreren Bedingungen
Muster muster = muster.comPile ("[, |]+"); String [] strs = muster.split ("Java Hallo Welt Java, Hallo, Welt | Sun"); für (int i = 0; i <strsgth; i ++) {System.out.println (strs [i]);};};};};};};}; ◆ Textersatz (Zeichen erscheint zum ersten Mal)
Muster muster = muster.comPile ("regulärer Ausdruck"); Matcher Matcher = muster.Matcher ("Regelmäßiger Ausdruck Hallo Welt, regulärer Ausdruck Hallo Welt"); // Ersetzen Sie die ersten Daten, die dem regulären System entsprechen. ◆ Textersatz (alle)
Muster muster = muster.comPile ("regulärer Ausdruck"); Matcher Matcher = muster.Matcher ("Regelmäßiger Ausdruck Hallo Welt, regulärer Ausdruck Hallo Welt"); // Ersetzen Sie die ersten Daten, die dem regulären System entsprechen. ◆ Textersatz (Ersetzen Sie Zeichen)
Muster muster = muster.comPile ("regulärer Ausdruck"); Matcher Matcher = muster.Matcher ("Regelmäßiger Ausdruck Hallo Welt, regulärer Ausdruck Hallo Welt"); StringBuffer sbr = new StringBuffer (); while (matcher.find ()) {matcher.Appendreplacement (SBR, "java");} Matcher.AppendTail (SBR); System.out.println (SBR.ToString ());◆ Stellen Sie sicher, ob es sich um eine E -Mail -Adresse handelt
String str = "[email protected]"; muster muster = muster.comPile ("[// w //./-]--]+@(?[///- ]+//.)+.../ W //-]+", muster.case_inemsitiv);
◆ Entfernen Sie HTML -Tags
Muster muster = muster.comPile ("<.+?>", Muster.dotall); Matcher Matcher = muster.Matcher ("<a href =/" index.html/"> home </a>"); String String = Matchner.Replaceall (""); System.println (String); ◆ Finden Sie die entsprechende Bedingungszeichenfolge in HTML
Pattern pattern = Pattern.compile("href=/"(.+?)/"");Matcher matcher = pattern.matcher("<a href=/"index.html/">Home</a>");if(matcher.find()) System.out.println(matcher.group(1));} ◆ Abfangen http: // Adresse
// intercept urlpattern muster = muster.comPile ("(http: // | https: //) {1} [//w//.//- while (matcher.find ()) {buffer.append (matcher.group ()); buffer.Append ("/r/n"); System.out.println (buffer.toString ());};◆ Ersetzen Sie die angegebenen {} chinesischen Zeichen
String str = "Die aktuelle Entwicklungsgeschichte von Java stammt aus {0} Jahren - {1} Jahre"; String [] [] Object = {new String [] {"// {0 //}", "1995"}, new String [] {"// {1 //}", "2007"}}; Sourcestring, Object [] Objekt) {String temp = Sourcestring; für (int i = 0; i <Object.length; i ++) {string [] result = (string []) Objekt [i]; Muster muster = muster.comPile (Ergebnis [0]); Matcher Matcher = muster.Matcher (temp); temp = matcher.replaceAll (Ergebnis [1]); } return temp;}◆ Abfragen Sie Dateien in ausgewiesenen Verzeichnissen unter regelmäßigen Bedingungen ab
// wird verwendet, um die Dateiliste privat ArrayList -Dateien = new ArrayList () zu Cache -Liste Cache -Liste. // verwendet, um den Dateipfad private String _path zu hosten; // Wird verwendet, um die reguläre Formel für private String _regexp zu hosten; Klasse myFileFilter implementiert FileFilter { / *** Übereinstimmung Dateiname* / public boolean Accept (Dateidatei) {try {mustermuster = muster.comPile (_regexp); Matcher match = muster.matcher (file.getName ()); return match.matches (); } catch (Ausnahme e) {return true; }}} / *** den Eingabestream analysieren* @param -Eingänge* / Dateianalyse (String -Pfad, String regexp) {getFileName (Pfad, regexp); } /** * Analysieren Sie den Dateinamen und fügen Sie Dateien hinzu * @param Eingabe * /private void getFileName (String -Pfad, String regexp) {// Directory_Path = Path; _regexp = regexp; Dateiverzeichnis = neue Datei (_Path); File [] fileFile = diriens.listfiles (new myFileFilter ()); if (filesFile == null) return; für (int j = 0; j <fileFile.length; j ++) {files.add (Dateifile [j]); } zurückkehren; } / *** Ausgabeinformationen anzeigen* @param out* / public void print (printstream) {iterator elements = files.iterator (); while (Elements.hasnext ()) {Datei file = (Datei) Elements.Next (); out.println (file.getPath ()); }} public static void output (String Pfad, String regexp) {fatesanalyze -DateiGroup1 = new FileAnalyze (Path, Regexp); DateiGroup1.print (System.out); } public static void main (String [] args) {output ("c: //", "[az |.]*"); }Es gibt viele Funktionen von Java -Regelmäßigkeit. Tatsächlich gibt es nichts, was Regelmäßigkeit nicht kann. (Natürlich braucht es viel Zeit, es regelmäßig zu erklären ||| ...)
Das obige sind die Informationen, die die regulären Ausdrücke von Java aussortieren. Wir werden in Zukunft weiterhin relevante Informationen hinzufügen. Vielen Dank für Ihre Unterstützung für diese Seite!