Ein regul\u00e4rer Ausdruck (engl. regular expression, kurz Regex) ist die Beschreibung eines Musters\u00a0(engl. pattern). Regul\u00e4re Ausdr\u00fccke werden bei der Zeichenkettenverarbeitung beim Suchen und Ersetzen eingesetzt. F\u00fcr folgende Szenarien bietet die Java-Bibliothek entsprechende Unterst\u00fctzung an:<\/p>\n
Tipp:\u00a0Regex-Ausdr\u00fccke lassen sich \u00fcber Tools visualisieren. Online ist das zum Beispiel mit https:\/\/www.debuggex.com\/ oder http:\/\/regexper.com\/ m\u00f6glich, http:\/\/xenon.stanford.edu\/~xusch\/regexp\/ \u00bbliest\u00ab regul\u00e4re Ausdr\u00fccke vor.<\/p>\n
Ein Pattern-Matcher\u00a0ist die \u00bbMaschine\u00ab, die regul\u00e4re Ausdr\u00fccke verarbeitet. Zugriff auf diese Mustermaschine bietet die Klasse Matcher. Dazu kommt die Klasse Pattern, die die regul\u00e4ren Ausdr\u00fccke in einem internen vorcompilierten Format repr\u00e4sentiert. Beide Klassen befinden sich im Paket java.util.regex. Um die Sache etwas zu vereinfachen, gibt es bei String zwei kleine Hilfsmethoden, die im Hintergrund auf die Klassen verweisen, um eine einfachere API anbieten zu k\u00f6nnen; diese nennen sich auch Fassaden-Methoden. Wir werden am Anfang erst mit den String-Methoden arbeiten und uns sp\u00e4ter die Klasse Pattern genauer anschauen. Die die Objektmethode matches(\u2026)\u00a0der Klasse String testet, ob ein regul\u00e4rer Ausdruck eine Zeichenfolge komplett beschreibt.<\/p>\n
In diesem Abschnitt wollen wir schauen, was ein Pattern-Matcher alles erkennen kann und wie die Syntax daf\u00fcr aussieht.<\/p>\n
Der einfachste regul\u00e4re Ausdruck besteht aus einzelnen Zeichen, den Literalen.<\/p>\n
| Ausdruck<\/td>\n | Ergebnis<\/td>\n<\/tr>\n | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| „tutego“.matches( „tutego“ )<\/td>\n | true<\/td>\n<\/tr>\n | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| „tutego“.matches( „Tutego“ )<\/td>\n | false<\/td>\n<\/tr>\n | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| „tutego“.matches( „-tutego-“ )<\/td>\n | false<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Tabelle: Einfache regul\u00e4re Ausdr\u00fccke und ihr Ergebnis<\/p>\n F\u00fcr diesen Fall ben\u00f6tigen wir keine regul\u00e4ren Ausdr\u00fccke, ein equals(\u2026) w\u00fcrde reichen.<\/p>\n Hinweis:\u00a0Bei Java ist es immer so, dass der regul\u00e4re Ausdruck den gesamten String komplett treffen muss, und nicht nur einen Teilstring. In nahezu jeder anderen Sprache und Bibliothek ist das nicht so, hier z\u00e4hlt ein Teilstring als \u201ematch\u201c. In einer JavaScript-Konsole:<\/p>\n „tutego“.match( \/tutego\/ )<\/p>\n [„tutego“, index: 0<\/strong>, input: „tutego“, groups: undefined]<\/p>\n „Tutego“.match( \/tutego\/ )<\/p>\n null<\/strong><\/p>\n „-tutego-„.match( \/tutego\/ )<\/p>\n [„tutego“, index: 1<\/strong>, input: „-tutego-„, groups: undefined]<\/p>\n In regul\u00e4ren Ausdr\u00fccken sind einige Zeichen reserviert, weshalb sie nicht als einfaches Literal gewertet werden. Zu diesen Zeichen mit besonders Bedeutung z\u00e4hlen: \\ (Backslash), ^ (Caret), $ (Dollarzeichen), . (Punkt), | vertikaler Strich, ? (Fragezeichen), * (Sternchen), + (Pluszeichen), (, ) (runde Klammer auf und zu), [, ] (eckige Klammer auf und zu), { (geschweifte Klammer auf).<\/p>\n Um diese Zeichen als Literal verwenden zu k\u00f6nnen ist eine Ausmaskierung mit \\ n\u00f6tig.<\/p>\n Metazeichen m\u00fcssen ausmaskiert werden<\/p>\n Der Ausdruck „11111“.matches(„1+1“)<\/strong> macht deutlich, dass + ein besonders Symbol ist, was f\u00fcr Wiederholungen steht. Wird es, wie im letzten Fall, falsch angewendet, folgt eine Ausnahme.<\/p>\n Mit einer Zeichenklasse\u00a0ist es m\u00f6glich ein von mehren Zeichen aus einer Menge zu matchen. So steht [aeiou] f\u00fcr eines der Zeichen a, e, i, o oder u. Die Reihenfolge der Zeichen spielt keine Rolle. Mit einem Minuszeichen lassen sich Bereiche definieren. So steht [0-9a-fA-F] f\u00fcr die Zeichen 0, 1, 2, \u2026, 9 oder Gro\u00df-\/Kleinbuchstaben a, b, c, d, e, f, A, B, C, D, E, F. Auch hier spielt die Reihenfolge keine Rolle, es h\u00e4tte auch [a-fA-F0-9] hei\u00dfen k\u00f6nnen. Mehrere Bereiche mit rechteckigen Klammern lassen sich hintereinander stellen.<\/p>\n Die Metazeichen wie * oder + k\u00f6nnen ohne Ausmaskierung in Zeichenklassen verwendet werden, nur eben das Minus nicht, es sei denn, es steht am Anfang oder am Ende.<\/p>\n <\/p>\n Beispiel f\u00fcr Zeichenklassen<\/p>\n Hinweis:\u00a0<\/strong>Es ist wichtig daran zu denken, dass es immer nur einzelnen Zeichen sind und keine Zahlenbereiche. Wenn wir [1-99] vor uns haben, dann ist das mitnichten ein regul\u00e4rer Ausdruck f\u00fcr Zahlen von 1 bis 99, sondern nur die Ziffern 1, 2, 3, \u2026, 9 und dann noch einmal die 9 extra, was redundant ist, und gek\u00fcrzt werden kann auf [1-9].<\/p>\n Steht direkt hinter der \u00f6ffnenden eckigen Klammer ein ^, definiert das negative Zeichenklassen. Der Match ist dann auf allen Zeichen, die in der negativen Zeichenklasse nicht<\/em> vorkommen.<\/p>\n <\/p>\n Beispiel f\u00fcr negative Zeichenklassen<\/p>\n Das letzte Beispiel macht deutlich, dass eine negative Zeichenklasse auch f\u00fcr ein Zeichen, n\u00e4mlich f\u00fcr ein Zeichen, das eben nicht +, -, *, \/ ist. Kein Zeichen kann das nicht sein.<\/p>\n Der . (Punkt) ist ein m\u00e4chtiges Metazeichen und steht f\u00fcr (fast) jedes erdenkliche Zeichen.<\/p>\n Hinweis:\u00a0<\/strong>Der . (Punkt) matcht standardm\u00e4\u00dfig keinen Zeilenumbruch. Das hat historische Gr\u00fcnde, denn die ersten Werkzeuge arbeiteten zeilenbasiert, und da war es nicht gew\u00fcnscht, wenn der Ausdruck mit auf die n\u00e4chste Zeile ging. In Java k\u00f6nnen wir einstellen, ob der Punkt auch einen Zeilenumbruch erkennen soll.<\/p>\n Beispiel mit dem Punkt<\/p>\n Gewisse Zeichenklassen kommen immer wieder vor, etwa f\u00fcr Ziffern. Daher gibt es vordefinierte Zeichenklassen, die uns Schreibarbeit ersparen und den regul\u00e4ren Ausdruck \u00fcbersichtlicher machen. Die wichtigsten sind:<\/p>\n Tabelle: Vordefinierte Zeichenklassen<\/p>\n Bei den Wortzeichen handelt es sich standardm\u00e4\u00dfig um die ASCII-Zeichen und nicht um deutsche Zeichen mit unseren Umlauten oder allgemeine Unicode-Zeichen. Eine umfassende \u00dcbersicht liefert die API-Dokumentation der Klasse java.util.regex.Pattern unter https:\/\/docs.oracle.com\/javase\/10\/docs\/api\/java\/util\/regex\/Pattern.html, die auch weitere vordefinierte Zeichenklassen auflistet.<\/p>\n <\/p>\n Beispiel mit vordefinierten Zeichenklassen<\/p>\n Steht hinter einem Zeichen ein Fragezeichen, so ist es optional. Das Fragezeichen nennen wir auch Quantifizierer. Auch hinter einer Zeichenklasse, vordefinierten Zeichenklasse ist ein Fragezeichen erlaubt. Mehrere Zeichen k\u00f6nnen durch runde Klammen zusammengefasst werden.<\/p>\n <\/p>\n Beispiel mit optionalen Zeichenfolgen<\/p>\n Neben dem Fragzeichen an gibt es weitere Quantifizierer. F\u00fcr eine Zeichenkette X gilt:<\/p>\n <\/p>\n Tabelle: Quantifizierer im Umgang mit einer Zeichenkette X<\/p>\n Sehen wir uns ein paar Ausdr\u00fccke an:<\/p>\n Tabelle: Beispiele f\u00fcr regul\u00e4re Ausdr\u00fccke mit Wiederholungen<\/p>\n Eine Sonderform ist X(?!Y) \u2013 das dr\u00fcckt aus, dass der regul\u00e4re Ausdruck Y dem regul\u00e4ren Ausdruck X nicht folgen darf (die API-Dokumentation spricht von \u00bbzero-width negative lookahead\u00ab).<\/p>\n Ein weiterer Quantifizierer kann die Anzahl einschr\u00e4nken und die Anzahl eines Vorkommens genauer beschreiben:<\/p>\n Beispiel<\/p>\n Eine E-Mail-Adresse endet mit einem Domain-Namen, der zwei oder drei Zeichen lang ist. Ein einfacher regul\u00e4rer Ausdruck sieht aus aus: „[\\\\w|-]+@\\\\w[\\\\w|-]*\\\\.[a-z]{2,3}“.<\/p>\n Der Aufruf der Objektmethode matches(String) auf einem String-Objekt bzw. das statische Pattern.matches(String, CharSequence) ist nur eine Abk\u00fcrzung f\u00fcr die \u00dcbersetzung eines Patterns und Anwendung von matches() auf einem Matcher-Objekt.<\/p>\n Tabelle: Implementierungen der beiden matches(…)-Methoden<\/p>\n W\u00e4hrend also die Objektmethode matches(String) von String zu Pattern.matches(String, CharSequence) delegiert, steht hinter der statischen Fassadenmethode in Pattern die wirkliche Nutzung der beiden zentralen Klassen Pattern f\u00fcr das Muster und Matcher f\u00fcr die Mustermaschine. Wenn wir also schreiben „Filk“.matches(„F..k“) ist das \u00e4quivalent zu Pattern.matches(„F..k“, „Filk“) und das ist \u00e4quivalent zu<\/p>\n Pattern p = Pattern.compile( „F..k“ ); Ein regul\u00e4rer Ausdruck (engl. regular expression, kurz Regex) ist die Beschreibung eines Musters\u00a0(engl. pattern). Regul\u00e4re Ausdr\u00fccke werden bei der Zeichenkettenverarbeitung beim Suchen und Ersetzen eingesetzt. F\u00fcr folgende Szenarien bietet die Java-Bibliothek entsprechende Unterst\u00fctzung an: Frage nach einer kompletten \u00dcbereinstimmung: Passt eine Zeichenfolge komplett auf ein Muster? Wir nennen das vollst\u00e4ndigen Match. Die R\u00fcckgabe einer solchen […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[11],"tags":[],"class_list":["post-4224","post","type-post","status-publish","format-standard","hentry","category-insel"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4224","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=4224"}],"version-history":[{"count":1,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4224\/revisions"}],"predecessor-version":[{"id":4225,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4224\/revisions\/4225"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=4224"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=4224"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=4224"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}} |