Java-Regex
Der Java-Regex oder Regulärer Ausdruck ist eine API für Definieren Sie ein Muster zum Suchen oder Bearbeiten von Zeichenfolgen .
Es wird häufig verwendet, um die Einschränkung für Zeichenfolgen wie die Passwort- und E-Mail-Validierung zu definieren. Nachdem Sie das Java-Regex-Tutorial erlernt haben, können Sie Ihre regulären Ausdrücke mit dem Java Regex Tester Tool testen.
Die Java Regex API bietet 1 Schnittstelle und 3 Klassen in java.util.regex Paket.
java.util.regex-Paket
Die Klassen Matcher und Pattern bieten die Möglichkeit eines regulären Java-Ausdrucks. Das Paket java.util.regex stellt die folgenden Klassen und Schnittstellen für reguläre Ausdrücke bereit.
- MatchResult-Schnittstelle
- Matcher-Klasse
- Musterklasse
- PatternSyntaxException-Klasse
Matcher-Klasse
Es implementiert die MatchResult Schnittstelle. es ist ein Regex-Engine mit dem Übereinstimmungsoperationen für eine Zeichenfolge durchgeführt werden.
| NEIN. | Methode | Beschreibung |
|---|---|---|
| 1 | boolesche Übereinstimmungen() | Testen Sie, ob der reguläre Ausdruck mit dem Muster übereinstimmt. |
| 2 | boolescher find() | findet den nächsten Ausdruck, der dem Muster entspricht. |
| 3 | boolean find(int start) | findet den nächsten Ausdruck, der dem Muster ab der angegebenen Startnummer entspricht. |
| 4 | String-Gruppe() | gibt die übereinstimmende Teilsequenz zurück. |
| 5 | int start() | gibt den Startindex der übereinstimmenden Teilsequenz zurück. |
| 6 | beabsichtigen() | gibt den Endindex der übereinstimmenden Teilsequenz zurück. |
| 7 | int groupCount() | gibt die Gesamtzahl der übereinstimmenden Teilsequenzen zurück. |
Musterklasse
Es ist der kompilierte Version eines regulären Ausdrucks . Es wird verwendet, um ein Muster für die Regex-Engine zu definieren.
| NEIN. | Methode | Beschreibung |
|---|---|---|
| 1 | statisches Muster kompilieren (String-Regex) | kompiliert den angegebenen regulären Ausdruck und gibt die Instanz des Musters zurück. |
| 2 | Matcher-Matcher (CharSequence-Eingabe) | Erstellt einen Matcher, der die gegebene Eingabe mit dem Muster abgleicht. |
| 3 | statische boolesche Übereinstimmungen (String-Regex, CharSequence-Eingabe) | Es funktioniert als Kombination aus Kompilierungs- und Matcher-Methoden. Es kompiliert den regulären Ausdruck und gleicht die gegebene Eingabe mit dem Muster ab. |
| 4 | String[] split(CharSequence-Eingabe) | Teilt die angegebene Eingabezeichenfolge nach Übereinstimmungen mit dem angegebenen Muster auf. |
| 5 | String-Muster() | gibt das Regex-Muster zurück. |
Beispiel für reguläre Java-Ausdrücke
Es gibt drei Möglichkeiten, das Regex-Beispiel in Java zu schreiben.
import java.util.regex.*; public class RegexExample1{ public static void main(String args[]){ //1st way Pattern p = Pattern.compile('.s');//. represents single character Matcher m = p.matcher('as'); boolean b = m.matches(); //2nd way boolean b2=Pattern.compile('.s').matcher('as').matches(); //3rd way boolean b3 = Pattern.matches('.s', 'as'); System.out.println(b+' '+b2+' '+b3); }} Testen Sie es jetzt Ausgabe
true true true
Regulären Ausdruck . Beispiel
Der . (Punkt) steht für ein einzelnes Zeichen.
import java.util.regex.*; class RegexExample2{ public static void main(String args[]){ System.out.println(Pattern.matches('.s', 'as'));//true (2nd char is s) System.out.println(Pattern.matches('.s', 'mk'));//false (2nd char is not s) System.out.println(Pattern.matches('.s', 'mst'));//false (has more than 2 char) System.out.println(Pattern.matches('.s', 'amms'));//false (has more than 2 char) System.out.println(Pattern.matches('..s', 'mas'));//true (3rd char is s) }} Testen Sie es jetzt Regex-Zeichenklassen
| NEIN. | Charakterklasse | Beschreibung |
|---|---|---|
| 1 | [ABC] | a, b oder c (einfache Klasse) |
| 2 | [^abc] | Beliebiges Zeichen außer a, b oder c (Negation) |
| 3 | [a-zA-Z] | a bis z oder A bis Z, einschließlich (Bereich) |
| 4 | [a-d[m-p]] | a bis d oder m bis p: [a-dm-p] (Vereinigung) |
| 5 | [a-z&&[def]] | d, e oder f (Schnittpunkt) |
| 6 | [a-z&&[^bc]] | a bis z, außer b und c: [ad-z] (Subtraktion) |
| 7 | [a-z&&[^m-p]] | a bis z und nicht m bis p: [a-lq-z](Subtraktion) |
Beispiel für Zeichenklassen für reguläre Ausdrücke
import java.util.regex.*; class RegexExample3{ public static void main(String args[]){ System.out.println(Pattern.matches('[amn]', 'abcd'));//false (not a or m or n) System.out.println(Pattern.matches('[amn]', 'a'));//true (among a or m or n) System.out.println(Pattern.matches('[amn]', 'ammmna'));//false (m and a comes more than once) }} Testen Sie es jetzt Regex-Quantifizierer
Die Quantoren geben die Häufigkeit des Vorkommens eines Zeichens an.
| Regex | Beschreibung |
|---|---|
| X? | X kommt einmal oder gar nicht vor |
| X+ | X kommt einmal oder mehrmals vor |
| X* | X kommt null oder mehrmals vor |
| X{n} | X kommt nur n-mal vor |
| X{n,} | X kommt n-mal oder öfter vor |
| X{y,z} | X kommt mindestens y-mal, aber weniger als z-mal vor |
Beispiel für reguläre Ausdruckszeichenklassen und Quantifizierer
import java.util.regex.*; class RegexExample4{ public static void main(String args[]){ System.out.println('? quantifier ....'); System.out.println(Pattern.matches('[amn]?', 'a'));//true (a or m or n comes one time) System.out.println(Pattern.matches('[amn]?', 'aaa'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aammmnn'));//false (a m and n comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aazzta'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'am'));//false (a or m or n must come one time) System.out.println('+ quantifier ....'); System.out.println(Pattern.matches('[amn]+', 'a'));//true (a or m or n once or more times) System.out.println(Pattern.matches('[amn]+', 'aaa'));//true (a comes more than one time) System.out.println(Pattern.matches('[amn]+', 'aammmnn'));//true (a or m or n comes more than once) System.out.println(Pattern.matches('[amn]+', 'aazzta'));//false (z and t are not matching pattern) System.out.println('* quantifier ....'); System.out.println(Pattern.matches('[amn]*', 'ammmna'));//true (a or m or n may come zero or more times) }} Testen Sie es jetzt Regex-Metazeichen
Die Metazeichen regulärer Ausdrücke fungieren als Shortcodes.
| Regex | Beschreibung |
|---|---|
| . | Beliebiges Zeichen (kann mit dem Abschlusszeichen übereinstimmen oder nicht) |
| D | Alle Ziffern außer [0-9] |
| D | Alle Nicht-Ziffern, kurz für [^0-9] |
| S | Beliebiges Leerzeichen, kurz für [ x0Bf ] |
| S | Jedes Zeichen, das kein Leerzeichen ist, kurz für [^s] |
| In | Beliebiges Wortzeichen, Kurzform für [a-zA-Z_0-9] |
| IN | Jedes Nicht-Wort-Zeichen, kurz für [^w] |
| B | Eine Wortgrenze |
| B | Eine Nicht-Wortgrenze |
Beispiel für reguläre Ausdrucks-Metazeichen
import java.util.regex.*; class RegexExample5{ public static void main(String args[]){ System.out.println('metacharacters d....');\d means digit System.out.println(Pattern.matches('\d', 'abc'));//false (non-digit) System.out.println(Pattern.matches('\d', '1'));//true (digit and comes once) System.out.println(Pattern.matches('\d', '4443'));//false (digit but comes more than once) System.out.println(Pattern.matches('\d', '323abc'));//false (digit and char) System.out.println('metacharacters D....');\D means non-digit System.out.println(Pattern.matches('\D', 'abc'));//false (non-digit but comes more than once) System.out.println(Pattern.matches('\D', '1'));//false (digit) System.out.println(Pattern.matches('\D', '4443'));//false (digit) System.out.println(Pattern.matches('\D', '323abc'));//false (digit and char) System.out.println(Pattern.matches('\D', 'm'));//true (non-digit and comes once) System.out.println('metacharacters D with quantifier....'); System.out.println(Pattern.matches('\D*', 'mak'));//true (non-digit and may come 0 or more times) }} Testen Sie es jetzt Frage zum regulären Ausdruck 1
/*Create a regular expression that accepts alphanumeric characters only. Its length must be six characters long only.*/ import java.util.regex.*; class RegexExample6{ public static void main(String args[]){ System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun32'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'kkvarun32'));//false (more than 6 char) System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'JA2Uk2'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun$2'));//false ($ is not matched) }} Testen Sie es jetzt
Frage zu regulären Ausdrücken 2
/*Create a regular expression that accepts 10 digit numeric characters starting with 7, 8 or 9 only.*/ import java.util.regex.*; class RegexExample7{ public static void main(String args[]){ System.out.println('by character classes and quantifiers ...'); System.out.println(Pattern.matches('[789]{1}[0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '99530389490'));//false (11 characters) System.out.println(Pattern.matches('[789][0-9]{9}', '6953038949'));//false (starts from 6) System.out.println(Pattern.matches('[789][0-9]{9}', '8853038949'));//true System.out.println('by metacharacters ...'); System.out.println(Pattern.matches('[789]{1}\d{9}', '8853038949'));//true System.out.println(Pattern.matches('[789]{1}\d{9}', '3853038949'));//false (starts from 3) }} Testen Sie es jetzt Beispiel für einen Java-Regex-Finder
import java.util.regex.Pattern; import java.util.Scanner; import java.util.regex.Matcher; public class RegexExample8{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); while (true) { System.out.println('Enter regex pattern:'); Pattern pattern = Pattern.compile(sc.nextLine()); System.out.println('Enter text:'); Matcher matcher = pattern.matcher(sc.nextLine()); boolean found = false; while (matcher.find()) { System.out.println('I found the text '+matcher.group()+' starting at index '+ matcher.start()+' and ending at index '+matcher.end()); found = true; } if(!found){ System.out.println('No match found.'); } } } } Ausgabe:
Enter regex pattern: java Enter text: this is java, do you know java I found the text java starting at index 8 and ending at index 12 I found the text java starting at index 26 and ending at index 30
