java regex tutorial with regular expression examples
In diesem Java Regex-Lernprogramm wird anhand von Beispielen für reguläre Ausdrücke erläutert, was ein regulärer Ausdruck in Java ist, warum wir ihn benötigen und wie er verwendet wird:
ZU regulären Ausdruck in Java wird das mit „ Regex ”Ist ein Ausdruck, mit dem ein Suchmuster für Zeichenfolgen definiert wird.
Das Suchmuster kann ein einfaches Zeichen oder ein Teilstring sein oder es kann eine komplexe Zeichenfolge oder ein Ausdruck sein, der ein bestimmtes Muster definiert, das in der Zeichenfolge gesucht werden soll.
Ferner muss das Muster möglicherweise ein- oder mehrmals mit der Zeichenfolge übereinstimmen.
=> Besuchen Sie hier, um die Java-Schulungsreihe für alle zu sehen.
Was du lernen wirst:
Regulärer Ausdruck: Warum wir ihn brauchen
Ein regulärer Ausdruck wird hauptsächlich verwendet, um nach einem Muster in einer Zeichenfolge zu suchen. Warum suchen wir nach einem Muster in einer Zeichenfolge? Möglicherweise möchten wir ein bestimmtes Muster in einer Zeichenfolge finden und es dann bearbeiten oder bearbeiten.
In einer Computeranwendung müssen wir möglicherweise ständig verschiedene Muster bearbeiten. Daher benötigen wir immer Regex, um die Suche nach dem Muster zu erleichtern.
Wie genau funktioniert der Regex, wenn nun ein Muster für die Suche angegeben wird?
Wenn wir den Text mithilfe eines regulären Ausdrucks analysieren und ändern, sagen wir: 'Wir haben den regulären Ausdruck auf die Zeichenfolge oder den Text angewendet.' Wir wenden das Muster in einer Richtung von links nach rechts auf den Text an und die Quellzeichenfolge wird mit dem Muster abgeglichen.
Zum Beispiel, Betrachten Sie eine Zeichenfolge “ ababababab ”. Nehmen wir an, dass ein regulärer Ausdruck 'aba' definiert ist. Jetzt müssen wir diesen regulären Ausdruck auf die Zeichenfolge anwenden. Wenn Sie den regulären Ausdruck von links nach rechts anwenden, stimmt der reguläre Ausdruck mit der Zeichenfolge überein. “ aba_aba___ An zwei Stellen.
Sobald ein Quellzeichen in einer Übereinstimmung verwendet wird, können wir es nicht mehr wiederverwenden. Nachdem das erste Match aba gefunden wurde, wurde das dritte Zeichen 'a' nicht wiederverwendet.
Löschen eines Elements aus einem Java-Array
java.util.regex
Die Java-Sprache bietet keine integrierte Klasse für Regex. Aber wir können mit regulären Ausdrücken arbeiten, indem wir das “ java.util.regex ”Paket.
Das Paket java.util.regex bietet eine Schnittstelle und drei Klassen, wie unten gezeigt:
Musterklasse: Eine Musterklasse repräsentiert den kompilierten regulären Ausdruck. Die Pattern-Klasse verfügt über keine öffentlichen Konstruktoren, bietet jedoch statische compile () -Methoden, die Pattern-Objekte zurückgeben und zum Erstellen eines Musters verwendet werden können.
Matcher-Klasse: Das Matcher-Klassenobjekt passt das Regex-Muster an die Zeichenfolge an. Wie die Pattern-Klasse stellt auch diese Klasse keine öffentlichen Konstruktoren bereit. Es stellt die matcher () -Methode bereit, die ein Matcher-Objekt zurückgibt.
PatternSyntaxException: Diese Klasse definiert eine nicht aktivierte Ausnahme. Ein Objekt vom Typ PatternSyntaxException gibt eine ungeprüfte Ausnahme zurück, die auf einen Syntaxfehler im Regex-Muster hinweist.
MatchResult-Schnittstelle: Die MatchResult-Schnittstelle bestimmt das Ergebnis der Regex-Musterübereinstimmung.
Java Regex Beispiel
Lassen Sie uns ein einfaches Beispiel für Regex in Java implementieren. Im folgenden Programm haben wir eine einfache Zeichenfolge als Muster und ordnen sie dann einer Zeichenfolge zu. Die Ausgabe gibt die Start- und Endposition in der Zeichenfolge aus, in der sich das Muster befindet.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String args()) { //define a pattern to be searched Pattern pattern = Pattern.compile('Help.'); // Search above pattern in 'softwareTestingHelp.com' Matcher m = pattern.matcher('softwareTestingHelp.com'); // print the start and end position of the pattern found while (m.find()) System.out.println('Pattern found from position ' + m.start() + ' to ' + (m.end()-1)); } } Ausgabe:
Muster gefunden von 15 bis 19
Regex Matcher In Java
Die Matcher-Klasse implementiert die MatchResult-Schnittstelle. Matcher fungiert als Regex-Engine und wird verwendet, um den genauen Abgleich einer Zeichenfolge durchzuführen.
Im Folgenden sind die gängigen Methoden der Matcher-Klasse aufgeführt. Es gibt mehr Methoden, aber wir haben unten nur die wichtigen Methoden aufgelistet.
| Unterlassen Sie | Methode | Beschreibung |
|---|---|---|
| 7 | int start () | Gibt den Startindex der übereinstimmenden Teilsequenz an und gibt ihn zurück. |
| 1 | Boolesche Übereinstimmungen () | Überprüft, ob der Regex mit dem Muster übereinstimmt. |
| zwei | Muster Muster () | Gibt das Muster zurück, das der Matcher interpretiert. |
| 3 | boolean find () | Diese Methode findet den nächsten Ausdruck, der mit dem Muster übereinstimmt. |
| 4 | boolescher Fund (int start) | Entspricht find (), findet jedoch den Ausdruck, der von der angegebenen Startposition aus übereinstimmt. |
| 5 | String group () | Gibt die Teilsequenz zurück, die dem Muster entspricht. |
| 6 | String-Gruppe (String-Name) | Gibt die Eingabe-Teilsequenz zurück. Dies wird in der früheren Übereinstimmungsoperation erfasst, indem die Gruppe mit dem angegebenen Namen erfasst wird. |
| 8 | int end () | Gibt die Endposition / den Index der übereinstimmenden Teilsequenz zurück. |
| 9 | int groupCount () | Gibt die Gesamtzahl der übereinstimmenden Teilsequenzen zurück. |
| 10 | String replaceAll (Stringersatz) | Ersetzen Sie alle Teilsequenzen der Eingabesequenz, die dem Muster entsprechen, durch eine bestimmte Ersetzungszeichenfolge. |
| elf | String replaceFirst (Stringersatz) | Ersetzen Sie die erste übereinstimmende Teilsequenz der Eingabesequenz durch die angegebene Ersetzungszeichenfolge. |
| 12 | String toString () | Gibt die Zeichenfolgendarstellung des aktuellen Matchers zurück. |
Implementierungsbeispiel für reguläre Ausdrücke
Sehen wir uns ein Beispiel für die Verwendung einiger dieser Methoden an.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherDemo { public static void main(String() args) { String inputString = 'She sells sea shells on the sea shore with shells'; //obtain a Pattern object Pattern pattern = Pattern.compile('shells'); // obtain a matcher object System.out.println('input string: ' + inputString); Matcher matcher = pattern.matcher(inputString); inputString = matcher.replaceFirst('pearls'); System.out.println('
replaceFirst method:' + inputString); //use replaceAll method to replace all occurrences of pattern inputString = matcher.replaceAll('pearls'); System.out.println('
replaceAll method:' + inputString); } } Ausgabe:
Eingabezeichenfolge: Sie verkauft Muscheln am Meer mit Muscheln
ErsetzenErste Methode: Sie verkauft Seeperlen am Meer mit Muscheln
replaceAll-Methode: Sie verkauft Seeperlen am Meer mit Perlen
Regex-Musterklasse in Java
Die Musterklasse definiert das Muster für die Regex-Engine, das dann zur Übereinstimmung mit der Eingabezeichenfolge verwendet werden kann.
Die folgende Tabelle zeigt die Methoden der häufig verwendeten Pattern-Klasse.
| Unterlassen Sie | Methode | Beschreibung |
|---|---|---|
| 7 | String () split (CharSequence-Eingabe, int limit) | Die Eingabezeichenfolge wird um Übereinstimmungen aufgeteilt, die von einem bestimmten Muster gefunden wurden. |
| 1 | statische Musterkompilierung (String regex) | Gibt eine kompilierte Darstellung des regulären Ausdrucks zurück. |
| zwei | statische Musterkompilierung (String regex, int flags) | Kompiliert den angegebenen regulären Ausdruck unter Verwendung der angegebenen Flags und gibt das Muster zurück. |
| 3 | Übereinstimmungen Übereinstimmungen (CharSequence-Eingabe) | Gibt einen Matcher zurück, indem die Eingabesequenz mit dem Muster abgeglichen wird. |
| 4 | statische boolesche Übereinstimmungen (String-Regex, CharSequence-Eingabe) | Kompiliert den angegebenen regulären Ausdruck und ordnet das Muster einer bestimmten Eingabe zu. |
| 5 | int flags () | Gibt Flags des Musters zurück, mit dem der Abgleich durchgeführt wird. |
| 6 | String () split (CharSequence-Eingabe) | Die Eingabezeichenfolge wird um Übereinstimmungen aufgeteilt, die von einem bestimmten Muster gefunden wurden. |
| 8 | String pattern () | Gibt das Muster für reguläre Ausdrücke zurück. |
| 9 | statisches String-Zitat (String s) | Gibt eine Literalzeichenfolge (Muster) für die angegebene Zeichenfolge zurück. |
| 10 | String toString () | Erhalten Sie eine Zeichenfolgendarstellung des Musters. |
Im folgenden Beispiel werden einige der oben genannten Methoden der Pattern-Klasse verwendet.
import java.util.regex.*; public class Main { public static void main(String() args) { // define a REGEX String String REGEX = 'Test'; // string to be searched for given pattern String actualString = 'Welcome to SoftwareTestingHelp portal'; // generate a pattern for given regex using compile method Pattern pattern = Pattern.compile(REGEX); // set limit to 2 int limit = 2; // use split method to split the string String() array = pattern.split(actualString, limit); // print the generated array for (int i = 0; i Regex String Matches-Methode Wir haben die String.Contains () -Methode in unseren String-Tutorials gesehen. Diese Methode gibt einen booleschen Wert true oder false zurück, je nachdem, ob die Zeichenfolge ein bestimmtes Zeichen enthält oder nicht.
In ähnlicher Weise haben wir eine Methode 'match ()', um zu überprüfen, ob die Zeichenfolge mit einem regulären Ausdruck oder einem regulären Ausdruck übereinstimmt. Wenn die Zeichenfolge mit dem angegebenen regulären Ausdruck übereinstimmt, wird ein true-Wert oder false zurückgegeben.
Die allgemeine Syntax der match () -Methode:
public boolean matches (String regex)Wenn der angegebene reguläre Ausdruck nicht gültig ist, wird die 'PatternSyntaxException' ausgelöst.
Beispiele für User Stories mit Akzeptanzkriterien
Implementieren wir ein Programm, um die Verwendung der match () -Methode zu demonstrieren.
public class MatchesExample{ public static void main(String args()){ String str = new String('Java Series Tutorials'); System.out.println('Input String: ' + str); //use matches () method to check if particular regex matches to the given input System.out.print('Regex: (.*)Java(.*) matches string? ' ); System.out.println(str.matches('(.*)Java(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)Series(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)String(.*)')); System.out.print('Regex: (.*)Tutorials matches string? ' ); System.out.println(str.matches('(.*)Tutorials')); } } Ausgabe:
Eingabezeichenfolge: Java Series Tutorials
Regex: (. *) Java (. *) Entspricht der Zeichenfolge? wahr
Regex: (. *) Serie (. *) Stimmt mit String überein? wahr
Regex: (. *) Serie (. *) Stimmt mit String überein? falsch
Regex: (. *) Tutorials stimmen mit Zeichenfolge überein? wahr
Wir verwenden viele Sonderzeichen und Metazeichen mit regulären Ausdrücken in Java. Wir verwenden auch viele Zeichenklassen für den Mustervergleich. In diesem Abschnitt stellen wir die Tabellen bereit, die Zeichenklassen, Metazeichen und Quantifizierer enthalten, die mit Regex verwendet werden können.
Regex-Zeichenklassen
Unterlassen Sie Zeichenklasse Beschreibung 7 (a-z && (^ m-p)) Subtraktion: a bis z und nicht m bis p: (a-lq-z) 1 (pqr) p, q oder r zwei (^ pqr) Negation: Jedes andere Zeichen als p, q oder r 3 (a-zA-Z) Bereich: a bis z oder A bis einschließlich Z 4 (a-d (m-p)) Union: a bis d oder m bis p: (a-dm-p) 5 (a-z && (def)) Schnittpunkt: d, e oder f 6 (a-z && (^ bc)) Subtraktion: a bis z, außer b und c: (ad-z)
Regex-Quantifizierer
Quantifizierer werden verwendet, um anzugeben, wie oft das Zeichen in der Regex vorkommt.
Die folgende Tabelle zeigt die in Java verwendeten allgemeinen Regex-Quantifizierer.
Unterlassen Sie Regex-Quantifizierer Beschreibung 7 IM Beliebiges Nicht-Wort-Zeichen, (^ w) 1 x? x erscheint einmal oder gar nicht zwei x + x erscheint einmal oder mehrmals 3 x * x kommt null oder mehrmals vor 4 x {n} x kommt n-mal vor 5 x {n,} x kommt n oder mehrmals vor 6 X und Z} x tritt mindestens y-mal, aber weniger als z-mal auf
Regex-Metazeichen
Die Metazeichen in Regex arbeiten als Kurzcode. Diese Codes enthalten Leerzeichen und Nicht-Leerzeichen sowie andere Shortcodes.
In der folgenden Tabelle sind die Regex-Metazeichen aufgeführt.
Unterlassen Sie Metazeichen Beschreibung 1 . Jedes Zeichen (kann mit dem Terminator übereinstimmen oder nicht) zwei d Beliebige Ziffern, (0-9) 3 D. Beliebige Nicht-Ziffern, (^ 0-9) 4 s Beliebiges Leerzeichen ( t n x0B f r) 5 S. Alle Nicht-Leerzeichen, (^ s) 6 im Beliebiges Wortzeichen (a-zA-Z_0-9) 8 b Eine Wortgrenze 9 B. Eine Nicht-Wort-Grenze
Im Folgenden wird ein Java-Programm angegeben, das die oben genannten Sonderzeichen im Regex verwendet.
import java.util.regex.*; public class RegexExample{ public static void main(String args()){ // returns true if string exactly matches 'Jim' System.out.print('Jim (jim):' + Pattern.matches('Jim', 'jim')); // Returns true if the input string is Peter or peter System.out.println('
(Pp)eter(Peter) :' + Pattern.matches('(Pp)eter', 'Peter')); //true if string = abc System.out.println('
.*abc.*(pqabcqp) :' + Pattern.matches('.*abc.*', 'pqabcqp')); // true if string doesn't start with a digit System.out.println('
^(^\d).*(abc123):' + Pattern.matches('^(^\d).*', 'abc123')); // returns true if the string contains exact three letters System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z) (aQz):' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z)', 'aQz')); System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z', 'a10z')); //input string length = 4 // true if the string contains 0 or more non-digits System.out.println('
\D*, abcde:' + Pattern.matches('\D*', 'abcde')); //True // true of line contains only word this ^-start of the line, $ - end of the line System.out.println('
^This$, This is Java:' + Pattern.matches('^This$', 'This is Java')); System.out.println('
^This$, This:' + Pattern.matches('^This$, This', 'This')); System.out.println('
^This$, Is This Java?:' + Pattern.matches('^This$, Is This Java?', 'Is This Java?')); } } Ausgabe:
Jim (Jim): falsch
(Pp) eter (Peter): wahr
. * abc. * (pqabcqp): true
^ (^ d). * (abc123): true
(a-zA-Z) (a-zA-Z) (a-zA-Z) (aQz): wahr
(a-zA-Z) (a-zA-Z) (a-zA-Z), a10zfalse
D *, abcde: true
^ This $, This is Java: false
^ This $, This: false
^ This $, Is This Java ?: False
Im obigen Programm haben wir verschiedene reguläre Ausdrücke bereitgestellt, die mit der Eingabezeichenfolge übereinstimmen. Den Lesern wird empfohlen, die Kommentare im Programm für jede Regex zu lesen, um das Konzept besser zu verstehen.
Regex Logical oder (|) Operator
Wir können den logischen oder (| Operator) in Regex verwenden, der uns die Wahl gibt, einen der Operanden von | auszuwählen Operator. Wir können diesen Operator in einem regulären Ausdruck verwenden, um eine Auswahl von Zeichen oder Zeichenfolgen zu treffen. Zum Beispiel, Wenn wir beide Wörter 'test' und 'Test' abgleichen möchten, werden wir diese Wörter als Test | test in die Logik oder den Operator aufnehmen.
Sehen wir uns das folgende Beispiel an, um diesen Operator zu verstehen.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexOR { public static void main(String() args) { // Regex string to search for patterns Test or test String regex = '(Test|test)'; // Compiles the pattern and obtains the matcher object from input string. Pattern pattern = Pattern.compile(regex); String input = 'Software Testing Help'; Matcher matcher = pattern.matcher(input); // print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } //define another input string and obtain the matcher object input = 'SoftwaretestingHelp'; matcher = pattern.matcher(input); // Print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } } } Ausgabe:
Text 'Test' bei 9 bis 13 gefunden.
Text 'Test' bei 8 bis 12 gefunden.
In diesem Programm haben wir den regulären Ausdruck '(Test | test)' bereitgestellt. Dann geben wir zuerst die Eingabezeichenfolge als 'Software Testing Help' an und stimmen mit dem Muster überein. Wir sehen, dass die Übereinstimmung gefunden und die Position gedruckt wird.
Als nächstes geben wir die Eingabezeichenfolge als 'SoftwaretestingHelp' an. Diesmal wird auch das Match gefunden. Dies liegt daran, dass der reguläre Ausdruck oder Operator und damit das Muster auf beiden Seiten von | verwendet wurde Der Operator wird mit der Zeichenfolge abgeglichen.
E-Mail-Validierung mit Regex
Wir können die E-Mail-ID (Adresse) auch mit Regex mithilfe der Methode java.util.regex.Pattern.matches () überprüfen. Es vergleicht die angegebene E-Mail-ID mit dem regulären Ausdruck und gibt true zurück, wenn die E-Mail gültig ist.
Das folgende Programm demonstriert die Validierung von E-Mails mithilfe von Regex.
public class EmailDemo { static boolean isValidemail(String email) { String regex = '^(\w-_\.+)*(\w-_\.)\@((\w)+\.)+(\w)+(\w)$'; //regex to validate email. return email.matches(regex); //match email id with regex and return the value } public static void main(String() args) { String email = 'ssthva@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); email = '@sth@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); } } Ausgabe:
Die E-Mail-ID lautet: ssthva@gmail.com
E-Mail-ID gültig? wahr
Die E-Mail-ID lautet: @ sth @ gmail.com
E-Mail-ID gültig? falsch
Wie wir aus der obigen Ausgabe sehen können, ist die erste E-Mail-ID gültig. Die zweite ID beginnt direkt mit @ und wird daher von Regex nicht validiert. Daher ist es eine ungültige ID.
So erstellen Sie eine gefälschte E-Mail-Domain
Häufig gestellte Fragen
F # 1) Was ist in einem regulären Ausdruck?
Antworten: ZU Regulären Ausdruck Im Allgemeinen wird Regex als Muster oder Folge von Zeichen (Normal- oder Sonderzeichen oder Metazeichen) bezeichnet, mit denen eine Eingabezeichenfolge überprüft wird.
F # 2) Welche Bedeutung hat die Matcher-Klasse für einen regulären Ausdruck in Java?
Antworten: Die Matcher-Klasse (java.util.regex.Matcher) fungiert als Regex-Engine. Es führt die Übereinstimmungsoperationen durch, indem es das Muster interpretiert.
F # 3) Wie ist das Muster in Java?
Antworten: Das Paket java.util.regex enthält eine Pattern-Klasse, mit der ein Regex zu einem Muster kompiliert wird, das die Standarddarstellung für Regex ist. Dieses Muster wird dann verwendet, um Zeichenfolgen zu validieren, indem es mit dem Muster abgeglichen wird.
F # 4) Was ist B in einem regulären Ausdruck?
Antworten: Das B in Regex wird als b bezeichnet und ist ein Ankerzeichen, das verwendet wird, um mit einer Position übereinzustimmen, die als Wortgrenze bezeichnet wird. Der Zeilenanfang ist mit einem Caret (^) und das Zeilenende mit einem Dollarzeichen ($) gekennzeichnet.
F # 5) Ist Muster-Thread-sicheres Java?
Antworten: Ja. Instanzen der Pattern-Klasse sind unveränderlich und für die Verwendung durch mehrere gleichzeitige Threads sicher. Die Instanzen der Matcher-Klasse sind jedoch nicht threadsicher.
Fazit
In diesem Tutorial haben wir reguläre Ausdrücke in Java erläutert. Der reguläre Ausdruck, der auch als 'regulärer Ausdruck' bezeichnet wird, wird zum Überprüfen der Eingabezeichenfolge in Java verwendet. Java bietet die java.util.regex ' Paket, das Klassen wie Pattern, Matcher usw. bereitstellt, mit deren Hilfe das Muster definiert und mit der Eingabezeichenfolge abgeglichen werden kann.
Wir haben auch verschiedene Sonderzeichenklassen und Metazeichen gesehen, die wir im regulären Ausdruck verwenden können und die Kurzcode für den Mustervergleich enthalten. Wir haben auch die E-Mail-Validierung mithilfe von Regex untersucht.
=> Entdecken Sie hier die Simple Java Training Series.
Literatur-Empfehlungen