Java-Funktionen und -Anwendungen für reguläre Ausdrücke

Autor：Eve Cole Aktualisierungszeit：2024-11-17 10:12:01

Ein regulärer Ausdruck ist eine Formel, die ein bestimmtes Muster verwendet, um einen Stringtyp zu finden. Ein regulärer Ausdruck besteht aus einigen gewöhnlichen Zeichen und einigen Metazeichen. Gewöhnliche Zeichen umfassen Groß- und Kleinbuchstaben und Zahlen, während Metazeichen eine besondere Bedeutung haben. Unabhängig davon, ob es sich um die .Net-Plattform oder die Java-Plattform handelt, ist die Bedeutung, die durch reguläre Ausdrücke ausgedrückt wird, im Folgenden hauptsächlich die gleiche Ich hoffe, dass der Artikel für Sie hilfreich ist und nur als Referenz dient.
Seit jdk1.4 das Paket java.util.regex gestartet hat, bietet es uns eine gute Java-Anwendungsplattform für reguläre Ausdrücke, da reguläre Java-Ausdrücke ein sehr komplexes System sind.
// Backslash
/t Intervall('/u0009')
/n Zeilenvorschub ('/u000A')
/r Enter('/u000D')
/d ist numerisch äquivalent zu [0-9]
/D Nicht-Zahl entspricht [^0-9]
/s Leerzeichen [/t/n/x0B/f/r]
/S Nicht-Leerzeichen [^/t/n/x0B/f/r]
/w einzelne Zeichen [a-zA-Z_0-9]
/W nicht getrennte Zeichen [^a-zA-Z_0-9]
/f Formularvorschubzeichen
/e Flucht
/b eine Wortgrenze
/B Eine Nicht-Wortgrenze
/G Ende des vorherigen Spiels
^ beginnt mit der Einschränkung
Die ^java-Bedingung ist auf Zeichen beschränkt, die mit Java beginnen
$ ist das Ende der Einschränkung
Die Java$-Bedingung ist auf Java als Endzeichen beschränkt
. Die Bedingung beschränkt jedes einzelne Zeichen außer /n
java.. Bedingung ist auf zwei beliebige Zeichen nach Java beschränkt, außer Newline
Spezifische Einschränkungen hinzufügen „[]“
Die [az]-Bedingung ist auf ein Zeichen im Bereich von Kleinbuchstaben a bis z beschränkt
Die Bedingung [AZ] ist auf ein Zeichen im Großbuchstabenbereich von A bis Z beschränkt
Die Bedingung [a-zA-Z] ist auf ein Zeichen im Bereich von Kleinbuchstaben a bis z oder Großbuchstaben A bis Z beschränkt
[0-9] Die Bedingung ist auf ein Zeichen im Bereich von Kleinbuchstaben 0 bis 9 beschränkt
[0-9a-z] Die Bedingung ist auf ein Zeichen im Bereich von Kleinbuchstaben 0 bis 9 oder a bis z beschränkt
[0-9[az]] Die Bedingung ist auf ein Zeichen (Schnittpunkt) im Bereich von Kleinbuchstaben 0 bis 9 oder a bis z beschränkt
Fügen Sie ^ zu [] hinzu und fügen Sie dann eine weitere Einschränkung hinzu: „[^]“.
Die Bedingung [^az] ist auf ein Zeichen im Bereich von a bis z, das kein Kleinbuchstabe ist, beschränkt
Die Bedingung [^AZ] ist auf ein Zeichen im Bereich von A bis Z beschränkt
[^a-zA-Z] Die Bedingung ist auf ein Zeichen im Bereich von Nicht-Kleinbuchstaben a bis z oder Großbuchstaben A bis Z beschränkt
[^0-9] Die Bedingung ist auf ein Zeichen im Bereich von 0 bis 9 (nicht Kleinbuchstaben) beschränkt
[^0-9a-z] Die Bedingung ist auf ein Zeichen im Bereich von Nicht-Kleinbuchstaben 0 bis 9 oder a bis z beschränkt
[^0-9[az]] Die Bedingung ist auf ein Zeichen (Schnittpunkt) im Bereich von Nicht-Kleinbuchstaben 0 bis 9 oder a bis z beschränkt
Wenn die Einschränkungsbedingung besagt, dass ein bestimmtes Zeichen mehr als 0 Mal vorkommt, können Sie „*“ verwenden.
J* mehr als 0J
.* 0 oder mehr Zeichen
J.* Mehr als 0 Zeichen zwischen DJ und D
Wenn die Einschränkungsbedingung darin besteht, dass ein bestimmtes Zeichen mehr als einmal vorkommt, können Sie „+“ verwenden.
J+ 1 oder mehr J
.+ 1 oder mehr Zeichen
J.+1 oder mehr Zeichen zwischen DJ und D
Wenn die Einschränkung darin besteht, dass ein bestimmtes Zeichen 0 oder öfter vorkommt, können Sie „?“ verwenden.
JA? J oder JA erscheint
Beschränkung auf die angegebene Anzahl aufeinanderfolgender Vorkommen des Zeichens „{a}“
J{2} JJ
J{3} JJJ
Es gibt mehr als ein Zeichen und „{a,}“
J{3,} JJJ,JJJJ,JJJJJ,???(J existiert mehr als dreimal gleichzeitig)
Mehr als Zeichen und weniger als b Zeichen „{a,b}“
J{3,5} JJJ oder JJJJ oder JJJJJ
Wählen Sie eines der beiden „|“
J|AJ oder A
Java|Hallo Java oder Hallo
„()“ gibt einen Kombinationstyp an . <BR>Wenn ich beispielsweise die Daten zwischen <a href></a> in <a href="index.html/">index</a> abfrage, können sie geschrieben werden als <a .*href=/".*/">(.+?)</a>
Wenn Sie die Funktion Pattern.compile verwenden, können Sie Parameter hinzufügen, die das Übereinstimmungsverhalten regulärer Java-Ausdrücke steuern:
Muster Pattern.compile(String regex, int flag)
Der Wertebereich von Flag ist wie folgt:
Pattern.CANON_EQ Eine Übereinstimmung wird genau dann berücksichtigt, wenn die „kanonische Zerlegung“ der beiden Zeichen genau gleich ist. Nach der Verwendung dieses Flags stimmt beispielsweise der Ausdruck „a/u030A“ mit „?“ überein. Standardmäßig wird die „kanonische Äquivalenz“ nicht berücksichtigt.
Pattern.CASE_INSENSITIVE(?i)
Standardmäßig funktioniert der Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung nur mit dem US-ASCII-Zeichensatz. Dieses Flag bewirkt, dass Ausdrücke unabhängig von der Groß-/Kleinschreibung abgeglichen werden. Um einen eindeutigen Abgleich von Unicode-Zeichen durchzuführen, kombinieren Sie einfach UNICODE_CASE mit diesem Flag.
Pattern.COMMENTS(?x)
In diesem Modus werden Leerzeichen in regulären Java-Ausdrücken beim Abgleich ignoriert (Anmerkung des Übersetzers: Es bezieht sich nicht auf „//s“ im Ausdruck, sondern auf Leerzeichen, Tabulatoren, Wagenrückläufe usw. im Ausdruck.) . Kommentare beginnen mit # und dauern bis zum Ende der Zeile. Der Unix-Zeilenmodus kann über ein eingebettetes Flag aktiviert werden.
Pattern.DOTALL(?s)
In diesem Modus kann der Ausdruck „.“ mit jedem Zeichen übereinstimmen, auch mit dem Ende einer Zeile. Standardmäßig stimmt der Ausdruck „.“ nicht mit Zeilenabschlusszeichen überein.
Muster.MULTILINE(?m)
In diesem Modus entsprechen „^“ und „$“ jeweils dem Anfang und dem Ende einer Zeile. Darüber hinaus entspricht „^“ immer noch dem Anfang der Zeichenfolge und „$“ entspricht auch dem Ende der Zeichenfolge. Standardmäßig stimmen diese beiden Ausdrücke nur mit dem Anfang und dem Ende der Zeichenfolge überein.
Pattern.UNICODE_CASE(?u)
Wenn Sie in diesem Modus auch das Flag CASE_INSENSITIVE aktivieren, werden Unicode-Zeichen ohne Berücksichtigung der Groß- und Kleinschreibung abgeglichen. Standardmäßig funktioniert der Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung nur mit dem US-ASCII-Zeichensatz.
Pattern.UNIX_LINES(?d)
In diesem Modus wird nur „/n“ als Zeilenumbruch betrachtet und mit „.“, „^“ und „$“ abgeglichen. Abgesehen von den vagen Konzepten sind hier ein paar einfache reguläre Java-Anwendungsfälle:
◆Zum Beispiel, wenn die Zeichenfolge eine Validierung enthält

Kopieren Sie den Codecode wie folgt:

//Suchen Sie eine Zeichenfolge, die mit Java beginnt und mit irgendetwas endet
Mustermuster = Pattern.compile("^Java.*");
Matcher matcher = pattern.matcher("Java ist kein Mensch");
boolean b= matcher.matches(); //Wenn die Bedingung erfüllt ist, wird true zurückgegeben, andernfalls wird false zurückgegeben
System.out.println(b);

Beim Teilen einer Zeichenfolge mit mehreren Bedingungen

Kopieren Sie den Codecode wie folgt:

Mustermuster = Pattern.compile("[, |]+");
String[] strs = pattern.split("Java Hello World Java,Hello,,World|Sun");
for (int i=0;i<strs.length;i++) {
System.out.println(strs[i]);
}

Textersetzung (erstes Vorkommen eines Zeichens)

Kopieren Sie den Codecode wie folgt:

Mustermuster = Pattern.compile("Java regulärer Ausdruck");
Matcher matcher = pattern.matcher("Java regulärer Ausdruck Hello World, regulärer Ausdruck Hello World");
//Ersetze die ersten Daten, die dem regulären Muster entsprechen
System.out.println(matcher.replaceFirst("Java"));

Textersetzung (alle)

Kopieren Sie den Codecode wie folgt:

Literale Ersetzung (Ersetzen von Zeichen)

Kopieren Sie den Codecode wie folgt:

Mustermuster = Pattern.compile("Java regulärer Ausdruck");
Matcher matcher = pattern.matcher("Java regulärer Ausdruck Hello World, regulärer Ausdruck Hello World");
StringBuffer sbr = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sbr, „Java“);
}
matcher.appendTail(sbr);
System.out.println(sbr.toString());

Überprüfen Sie, ob es sich um eine E-Mail-Adresse handelt

Kopieren Sie den Codecode wie folgt:

String str="[email protected]";
Mustermuster = Pattern.compile("[//w//.//-]+@([//w//-]+//.)+[//w//-]+",Pattern.CASE_INSENSITIVE );
Matcher matcher = pattern.matcher(str);
System.out.println(matcher.matches());

Entfernen Sie HTML-Tags

Kopieren Sie den Codecode wie folgt:

Mustermuster = Pattern.compile("<.+?>", Pattern.DOTALL);
Matcher matcher = pattern.matcher("<a href=/"index.html/">Homepage</a>");
String string = matcher.replaceAll("");
System.out.println(string);

Suchen Sie die entsprechende Bedingungszeichenfolge in HTML

Kopieren Sie den Codecode wie folgt:

Mustermuster = Pattern.compile("href=/"(.+?)/"");
Matcher matcher = pattern.matcher("<a href=/"index.html/">Homepage</a>");
if(matcher.find())
System.out.println(matcher.group(1));
}

◆http://address <BR>code abfangen

Kopieren Sie den Codecode wie folgt:

//URL abfangen
Mustermuster = Pattern.compile("(http://|https://){1}[//w//.//-/:]+");
Matcher matcher = pattern.matcher("dsdsds<http://dsds//gfgffdfd>fdf");
StringBuffer buffer = new StringBuffer();
while(matcher.find()){
buffer.append(matcher.group());
buffer.append("/r/n");
System.out.println(buffer.toString());
}

◆Ersetzen Sie den angegebenen {} chinesischen Zeichencode <BR>

Kopieren Sie den Codecode wie folgt:

String str = „Die aktuelle Entwicklungsgeschichte von Java reicht von {0} Jahren bis {1} Jahren“;
String[][] object={new String[]{"//{0/}",1995"},new String[]{"//{1/}",2007"}};
System.out.println(replace(str,object));
öffentlicher statischer String replace(final String sourceString,Object[] object) {
String temp=sourceString;
for(int i=0;i<object.length;i++){
String[] result=(String[])object[i];
Mustermuster = Pattern.compile(result[0]);
Matcher matcher = pattern.matcher(temp);
temp=matcher.replaceAll(result[1]);
}
Rücklauftemperatur;
}

◆Fragen Sie den Dateicode im angegebenen Verzeichnis unter Verwendung regulärer Bedingungen ab

Kopieren Sie den Codecode wie folgt:

//Wird zum Zwischenspeichern der Dateiliste verwendet
private ArrayList-Dateien = new ArrayList();
//Wird zum Hosten des Dateipfads verwendet
privater String _path;
//Wird verwendet, um nicht zusammengeführte reguläre Formeln zu übertragen
privater String _regexp;
Klasse MyFileFilter implementiert FileFilter {
/**
* Dateiname anpassen
*/
public boolean Accept(File file) {
versuchen {
Mustermuster = Pattern.compile(_regexp);
Matcher match = pattern.matcher(file.getName());
return match.matches();
} Catch (Ausnahme e) {
return true;
}
}
}
/**
* Analysieren Sie den Eingabestream
* @param-Eingaben
*/
FilesAnalyze (String-Pfad,String-Regexp){
getFileName(path,regexp);
}
/**
* Dateinamen analysieren und Dateien hinzufügen
* @param-Eingabe
*/
private void getFileName(String path,String regexp) {
//Inhaltsverzeichnis
_path=pfad;
_regexp=regexp;
Dateiverzeichnis = new File(_path);
File[] filesFile =directory.listFiles(new MyFileFilter());
if (filesFile == null) return;
for (int j = 0; j < filesFile.length; j++) {
files.add(filesFile[j]);
}
zurückkehren;
}
/**
* Ausgabeinformationen anzeigen
* @param raus
*/
public void print (PrintStream out) {
Iteratorelemente = files.iterator();
while (elements.hasNext()) {
Datei file=(Datei) elements.next();
out.println(file.getPath());
}
}
öffentliche statische void-Ausgabe (String-Pfad, String-Regexp) {
FilesAnalyze fileGroup1 = new FilesAnalyze(path,regexp);
fileGroup1.print(System.out);
}
public static void main (String[] args) {
Ausgabe("C://","[Az|.]*");
}

Reguläre Ausdrücke in Java haben viele Funktionen. Solange es sich um die Zeichenverarbeitung handelt, gibt es nichts, was reguläre Ausdrücke nicht können.