{"id":239,"date":"2024-02-22T22:54:31","date_gmt":"2024-02-22T21:54:31","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=239"},"modified":"2024-02-28T22:57:08","modified_gmt":"2024-02-28T21:57:08","slug":"regulaere-ausdruecke-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=239","title":{"rendered":"Regul\u00e4re Ausdr\u00fccke in Java"},"content":{"rendered":"\n

Regul\u00e4re Ausdr\u00fccke, auch als Regex oder RegExp bekannt, sind leistungsstarke Werkzeuge f\u00fcr das Musterabgleichen und die Textmanipulation. In Java werden regul\u00e4re Ausdr\u00fccke durch das Paket java.util.regex<\/code> implementiert, das eine umfangreiche Sammlung von Klassen und Methoden f\u00fcr die Arbeit mit Mustern bereitstellt. Dieser Artikel soll einen umfassenden Leitfaden f\u00fcr regul\u00e4re Ausdr\u00fccke in Java bieten, der die Grundlagen, fortgeschrittenen Einsatz und bew\u00e4hrte Praktiken abdeckt.<\/p>\n\n\n\n

Verst\u00e4ndnis von Regul\u00e4ren Ausdr\u00fccken<\/h2>\n\n\n\n

Im Kern ist ein regul\u00e4rer Ausdruck eine Zeichenfolge, die ein Suchmuster definiert. Diese Muster k\u00f6nnen verwendet werden, um Zeichenfolgen abzugleichen, Eingaben zu validieren oder komplexe Textmanipulationen durchzuf\u00fchren. In Java wird die Pattern<\/code>-Klasse verwendet, um einen kompilierten regul\u00e4ren Ausdruck zu repr\u00e4sentieren, und die Matcher<\/code>-Klasse hilft dabei, das Muster auf eine gegebene Eingabe anzuwenden.<\/p>\n\n\n\n

Grundlegende Muster und Zeichen<\/h3>\n\n\n\n

Beginnen wir mit den grundlegenden Bausteinen regul\u00e4rer Ausdr\u00fccke.<\/p>\n\n\n\n

    \n
  • Literale:<\/strong> Zeichen, die sich selbst entsprechen. Zum Beispiel wird der regul\u00e4re Ausdruck abc<\/code> die Zeichenfolge „abc“ genau abgleichen.<\/li>\n\n\n\n
  • Zeichenklassen:<\/strong> Definieren eine Menge von Zeichen, die abgeglichen werden sollen. Beispielsweise wird [aeiou]<\/code> zu jedem Vokal passen, und [^0-9]<\/code> zu jedem Nicht-Ziffern-Zeichen.<\/li>\n\n\n\n
  • Quantifizierer:<\/strong> Definieren die Anzahl der Vorkommen eines Zeichens oder einer Gruppe. H\u00e4ufig verwendete Quantifizierer sind *<\/code> (null oder mehr), +<\/code> (eins oder mehr), ?<\/code> (null oder eins) und {n, m}<\/code> (zwischen n und m Vorkommen).<\/li>\n\n\n\n
  • Metazeichen:<\/strong> Besondere Zeichen mit vordefinierten Bedeutungen. Beispiele sind .<\/code> (beliebiges Zeichen), ^<\/code> (Anfang einer Zeile), $<\/code> (Ende einer Zeile) und \\<\/code> (Escape-Zeichen).<\/li>\n<\/ul>\n\n\n\n

    Die Klasse Pattern<\/code><\/h3>\n\n\n\n

    In Java werden regul\u00e4re Ausdr\u00fccke in Pattern<\/code>-Objekte kompiliert. Die Klasse Pattern<\/code> bietet verschiedene statische Methoden zum Erstellen von Mustern, wie compile()<\/code> und matches()<\/code>.<\/p>\n\n\n

    import<\/span> java.util.regex.Pattern;\n\npublic class<\/span> RegexBeispiel<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        \/\/ Erstellen eines Musters<\/span>\n        Pattern pattern = Pattern.compile(\"[0-9]+\"<\/span>);\n\n        \/\/ Abgleichen einer Zeichenfolge<\/span>\n        boolean istTreffer = pattern.matcher(\"12345\"<\/span>).matches();\n        System.out.println(istTreffer); \/\/ Ausgabe: true<\/span>\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Die Klasse Matcher<\/code><\/h3>\n\n\n\n
    Nachdem ein Muster kompiliert wurde, wird die Klasse Matcher<\/code> verwendet, um das Muster auf eine bestimmte Eingabezeichenfolge anzuwenden. Sie bietet Methoden wie matches()<\/code>, find()<\/code> und group()<\/code>.<\/p>\n\n\n
    import<\/span> java.util.regex.Matcher;\nimport<\/span> java.util.regex.Pattern;\n\npublic class<\/span> MatcherBeispiel<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        \/\/ Erstellen eines Musters<\/span>\n        Pattern pattern = Pattern.compile(\"\\\\b\\\\d+\\\\b\"<\/span>);\n\n        \/\/ Erstellen eines Matchers<\/span>\n        Matcher matcher = pattern.matcher(\"123 456 789\"<\/span>);\n\n        \/\/ Suchen von Treffern<\/span>\n        while<\/span> (matcher.find()) {\n            System.out.println(\"Treffer: \"<\/span> + matcher.group());\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel passt das Muster \\b\\d+\\b<\/code> auf eine oder mehrere Ziffern zwischen Wortgrenzen.<\/p>\n\n\n\n
    Fortgeschrittene Verwendung<\/h2>\n\n\n\n
    Regul\u00e4re Ausdr\u00fccke werden m\u00e4chtiger, wenn grundlegende Elemente zu komplexen Mustern kombiniert werden.<\/p>\n\n\n\n
    Gruppen und Erfassen<\/h3>\n\n\n\n
    Gruppen sind Teile eines regul\u00e4ren Ausdrucks, die in Klammern eingeschlossen sind. Sie erm\u00f6glichen es, Quantifizierer auf mehrere Zeichen anzuwenden.<\/p>\n\n\n
    import<\/span> java.util.regex.Matcher;\nimport<\/span> java.util.regex.Pattern;\n\npublic class<\/span> GruppenBeispiel<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        \/\/ Erstellen eines Musters mit Gruppen<\/span>\n        Pattern pattern = Pattern.compile(\"([a-z]+)(\\\\d+)\"<\/span>);\n\n        \/\/ Erstellen eines Matchers<\/span>\n        Matcher matcher = pattern.matcher(\"abc123\"<\/span>);\n\n        \/\/ Extrahieren von erfassten Gruppen<\/span>\n        if<\/span> (matcher.matches()) {\n            String<\/span> buchstaben = matcher.group(1<\/span>);\n            String<\/span> ziffern = matcher.group(2<\/span>);\n            System.out.println(\"Buchstaben: \"<\/span> + buchstaben + \", Ziffern: \"<\/span> + ziffern);\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel erfasst das Muster ([a-z]+)(\\\\d+)<\/code> eine oder mehrere Buchstaben gefolgt von einer oder mehreren Ziffern.<\/p>\n\n\n\n
    Positive und Negative Lookahead\/Lookbehind<\/h3>\n\n\n\n
    Lookahead- und Lookbehind-Assertionen erm\u00f6glichen es, Bedingungen zu definieren, die f\u00fcr einen Treffer erf\u00fcllt sein m\u00fcssen, ohne den abgeglichenen Text im Ergebnis zu erfassen.<\/p>\n\n\n
    import<\/span> java.util.regex.Matcher;\nimport<\/span> java.util.regex.Pattern;\n\npublic class<\/span> LookaroundBeispiel<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        \/\/ Positive Lookahead-Assertion<\/span>\n        Pattern pattern = Pattern.compile(\"\\\\d(?=\\\\D)\"<\/span>);\n\n        \/\/ Erstellen eines Matchers<\/span>\n        Matcher matcher = pattern.matcher(\"1a 2b 3c\"<\/span>);\n\n        \/\/ Suchen von Treffern<\/span>\n        while<\/span> (matcher.find()) {\n            System.out.println(\"Treffer: \"<\/span> + matcher.group());\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel passt das Muster \\d(?=\\D)<\/code> auf eine Ziffer nur, wenn sie von einem Nicht-Ziffer-Zeichen gefolgt wird.<\/p>\n\n\n\n
    Gierige vs. Faule Quantifizierer<\/h3>\n\n\n\n
    Quantifizierer in regul\u00e4ren Ausdr\u00fccken sind standardm\u00e4\u00dfig gierig, d. h., sie passen so viel wie m\u00f6glich an. Wenn ein ?<\/code> nach einem Quantifizierer steht, wird dieser faul und passt so wenig wie m\u00f6glich an.<\/p>\n\n\n
    import<\/span> java.util.regex.Matcher;\nimport<\/span> java.util.regex.Pattern;\n\npublic class<\/span> GierigFauleBeispiel<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        \/\/ Gieriger Quantifizierer<\/span>\n        Pattern gierigesMuster = Pattern.compile(\"<.*>\"<\/span>);\n\n        \/\/ Fauler Quantifizierer<\/span>\n        Pattern faulesMuster = Pattern.compile(\"<.*?>\"<\/span>);\n\n        \/\/ Erstellen von Matchern<\/span>\n        Matcher gierigerMatcher = gierigesMuster.matcher(\"<tag>inhalt<\/tag>\"<\/span>);\n        Matcher faulerMatcher = faulesMuster.matcher(\"<tag>inhalt<\/tag>\"<\/span>);\n\n        \/\/ Suchen von Treffern<\/span>\n        while<\/span> (gierigerMatcher.find()) {\n            System.out.println(\"Gieriger Treffer: \"<\/span> + gierigerMatcher.group());\n        }\n\n        while<\/span> (faulerMatcher.find()) {\n            System.out.println(\"Faule Treffer: \"<\/span> + faulerMatcher.group());\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel passt das gierige Muster <.*><\/code> auf die gesamte Zeichenkette zwischen dem ersten <<\/code> und dem letzten ><\/code>, w\u00e4hrend das faule Muster <.*?><\/code> nur das zwischen jedem Paar von Tags passt.<\/p>\n\n\n\n
    Bew\u00e4hrte Praktiken und Tipps<\/h2>\n\n\n\n
      \n
    1. Bevorzugen Sie kompilierte Muster:<\/strong>
      Kompilieren Sie regul\u00e4re Ausdr\u00fccke immer, bevor Sie sie wiederholt verwenden. Die Kompilierung ist eine aufw\u00e4ndige Operation, und die Verwendung von kompilierten Mustern verbessert die Leistung.<\/li>\n<\/ol>\n\n\n
      \n\/\/ Bevorzugen Sie dies<\/span>\nPattern muster1 = Pattern.compile(\"\\\\d+\"<\/span>);\nPattern muster2 = Pattern.compile(\"\\\\w+\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        \n
      1. Verwenden Sie Zeichenklassen mit Bedacht:<\/strong>
        Zeichenklassen wie [a-z]<\/code> sind standardm\u00e4\u00dfig auf Gro\u00df-\/Kleinschreibung empfindlich. Wenn ein Fall-unsensitives Abgleichen gew\u00fcnscht ist, verwenden Sie die (?i)<\/code>-Flagge.<\/li>\n<\/ol>\n\n\n
        \/\/ Gro\u00df-\/Kleinschreibung beachten<\/span>\nPattern muster = Pattern.compile(\"[a-z]\"<\/span>);\n\n\/\/ Gro\u00df-\/Kleinschreibung ignorieren<\/span>\nPattern muster = Pattern.compile(\"(?i)[a-z]\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          \n
        1. Escape von Metazeichen:<\/strong>
          Achten Sie auf Metazeichen und escapen Sie sie, wenn sie als Literale behandelt werden sollen.<\/li>\n<\/ol>\n\n\n
          \/\/ Abgleichen eines literalen Punktes<\/span>\nPattern muster = Pattern.compile(\"\\\\.\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            \n
          1. Validieren Sie Eingaben mit matches()<\/code>:<\/strong>
            Die Methode matches()<\/code> \u00fcberpr\u00fcft, ob die gesamte Eingabezeichenfolge dem Muster entspricht. Verwenden Sie sie zur Eingabevalidierung.<\/li>\n<\/ol>\n\n\n
            \/\/ \u00dcberpr\u00fcfen, ob eine Zeichenfolge eine Zahl ist<\/span>\nif<\/span> (\"123\"<\/span>.matches(\"\\\\d+\"<\/span>)) {\n    System.out.println(\"G\u00fcltige Zahl\"<\/span>);\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>","protected":false},"excerpt":{"rendered":"
            Regul\u00e4re Ausdr\u00fccke, auch als Regex oder RegExp bekannt, sind leistungsstarke Werkzeuge f\u00fcr das Musterabgleichen und die Textmanipulation. In Java werden regul\u00e4re Ausdr\u00fccke durch das Paket java.util.regex implementiert, das eine umfangreiche Sammlung von Klassen und Methoden f\u00fcr die Arbeit mit Mustern bereitstellt. Dieser Artikel soll einen umfassenden Leitfaden f\u00fcr regul\u00e4re Ausdr\u00fccke in Java bieten, der die […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-239","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/239","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=239"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/239\/revisions"}],"predecessor-version":[{"id":240,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/239\/revisions\/240"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=239"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=239"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=239"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}