Hinweise zur Verwendung regulärer Ausdrücke in Java

Verschiedene Hinweise zur Verwendung regulärer Ausdrücke in Java.

Methoden, die reguläre Ausdrücke in der String-Klasse verwenden

Es gibt verschiedene Methoden in "String", die reguläre Ausdrücke akzeptieren.

• matches(String)
• replaceAll(String, String)
• replaceFirst(String, String)
• split(String, int)
• split(String)

matches(String)

package sample.regexp;

public class Main {

    public static void main(String[] args) {
        String text = "abc123";

        System.out.println(text.matches("[a-z0-9]+"));
        System.out.println(text.matches("[a-z]+"));
    }
}

Ausführungsergebnis

true
false

--Überprüfen Sie, ob die Zeichenfolge ** genau ** mit dem angegebenen regulären Ausdruck übereinstimmt

• Wenn nur ein Teil übereinstimmt, ist es "falsch"

replaceAll(String, String)

package sample.regexp;

public class Main {

    public static void main(String[] args) {
        String text = "abc123";

        System.out.println(text.replaceAll("[a-z]", "*"));
    }
}

Ausführungsergebnis

***123

• Übergeben Sie einen regulären Ausdruck als erstes Argument und ersetzen Sie alle übereinstimmenden Teile durch die Zeichenfolge des zweiten Arguments

Verwenden Sie die Gruppe, die der Ersatzzeichenfolge entspricht

package sample.regexp;

public class Main {

    public static void main(String[] args) {
        String text = "<<abc123>>";

        System.out.println(text.replaceAll("([a-z]+)([0-9]+)", "$0, $1, $2"));
    }
}

Ausführungsergebnis

<<abc123, abc, 123>>

• Durch Einfügen von "$ n" in die Ersatzzeichenfolge kann die übereinstimmende Gruppe nach dem Ersetzen wiederverwendet werden. -- n beginnt mit 0 --0 bezieht sich auf die gesamte übereinstimmende Zeichenfolge
• Da es sich um den Teil handelt, der mit ([a-z] +) ([0-9] +) übereinstimmt, ist abc123 das Ziel.
• Ab 1 können Sie der Reihe nach auf die in () eingeschlossenen Gruppen verweisen. -- $ 1 ist abc, das mit ([a-z] +) übereinstimmt,
• "$ 2" steht für "123", was "([0-9] +)" entspricht
• Wenn Sie eine Zahl für "n" angeben, die größer als die Anzahl der übereinstimmenden Gruppen ist, wird "IndexOutOfBoundsException" ausgelöst. --Wenn Sie es einfach durch die Zeichenfolge "$" ersetzen möchten, maskieren Sie es mit einem Backslash ("").
  • text.replaceAll("[a-z]+", "\\$")
• Wenn nicht entkommen, wird "IllegalArgumentException" ausgelöst
• Gruppen können neben Indizes auch namentlich bezeichnet werden
• Siehe [hier](#% E3% 82% B0% E3% 83% AB% E3% 83% BC% E3% 83% 97) für Details.

replaceFirst(String, String)

package sample.regexp;

public class Main {

    public static void main(String[] args) {
        String text = "abc123";

        System.out.println(text.replaceFirst("[a-z]", "*"));
    }
}

Ausführungsergebnis

*bc123

• Ersetzen Sie nur den ersten übereinstimmenden Teil des Teilstrings, der dem regulären Ausdruck entspricht
• Der Teilstring kann mit "$ n" referenziert werden, was mit "replaceAll ()" identisch ist.

split(String, int)

package sample.regexp;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        String text = "a1b2";
        
        for (int i=-1; i<5; i++) {
            String[] elements = text.split("[0-9]", i);
            System.out.println("limit=" + i + ",\telements=" + Arrays.toString(elements));
        }
    }
}

Ausführungsergebnis

limit=-1,	elements=[a, b, ]
limit=0,	elements=[a, b]
limit=1,	elements=[a1b2]
limit=2,	elements=[a, b2]
limit=3,	elements=[a, b, ]
limit=4,	elements=[a, b, ]

• Teilen Sie die Zeichenfolge an der Stelle auf, die dem im ersten Argument angegebenen regulären Ausdruck entspricht
• Das zweite Argument, limit, bestimmt die Obergrenze der Größe des Rückgabearrays.
• Wenn Sie für "limit" einen Wert größer oder gleich "1" angeben, wird der passende Teilstring auf "limit - 1" aufgeteilt.
• Wenn limit == 1, dann limit -1 => 0, so dass keine Aufteilung erfolgt (daher ist die Größe des Arrays 1).
• Im Fall von "limit == 2" wird es zu "limit --1 => 1", sodass die Division an dem "1" -Teil von "a1b2" durchgeführt wird, der zuerst mit dem regulären Ausdruck "[0-9]" übereinstimmt. Wir beenden dann die Teilung (was zu einer Arraygröße von "2" führt)
• Wenn für "limit" ein Wert kleiner oder gleich "0" angegeben wird, wird dieser als unbegrenzt behandelt und die Division wird bis zum Ende der Zeichenfolge ausgeführt.
• Das Verhalten, wenn am Ende (leer) keine Zeichenfolge mehr als Ergebnis der Aufteilung vorhanden ist, unterscheidet sich jedoch zwischen "0" und negativen Zahlen.
• Bei negativen Zahlen bleibt das letzte Leerzeichen auch als Element des Arrays erhalten --Wenn "0", wird das letzte Leerzeichen verworfen

Wenn der Anfang infolge der Division leer wird, wird das Leerzeichen so wie es ist als Element des Arrays festgelegt.

package sample.regexp;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        String text = "0a1b2";
        
        String[] elements = text.split("[0-9]", 0);
        System.out.println(Arrays.toString(elements));
    }
}

Ausführungsergebnis

[, a, b]

split(String) Dies ist das gleiche Verhalten wie das Setzen des zweiten Arguments von "split (String, int)" auf "0".

Musterklasse

Unterschied zur String-Methode

Mit einigen Ausnahmen [^ 1] Methoden, die die kanonische Delegierung der Klasse "String" hinter den Kulissen an die Klasse "Pattern" verwenden. Wenn Sie beispielsweise die Implementierung der Methode replaceAll () überprüfen, sieht dies folgendermaßen aus:

String.replaceAll()

    public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

Diese "Pattern" -Klasse (und "Matcher") ist für die Verarbeitung regulärer Ausdrücke in Java zuständig.

Die Klasse "Pattern" interpretiert die von "compile ()" übergebene Zeichenfolge als regulären Ausdruck. Wenn der verwendete reguläre Ausdruck festgelegt ist, ist es effizienter, dieses compile () nur beim ersten Mal auszuführen und dann die Pattern-Instanz wiederzuverwenden. (Die Klasse "Pattern" ist unveränderlich, sodass sie auch beim Multithreading sicher wiederverwendet werden kann.)

Dieses compile () wird jedoch jedes Mal ausgeführt, wenn die Methode verwendet wird, die den regulären Ausdruck der String-Klasse verwendet. Wenn Sie die Methode "String" verwenden, um einen festen regulären Ausdruck immer wieder auszuführen, ist die Verarbeitungsgeschwindigkeit daher langsamer als bei Verwendung der Instanz "Pattern".

Beispiel für die Verwendung von Pattern

public class Hoge {
    //Verwenden Sie die kompilierte Pattern-Instanz erneut
    private static final Pattern HOGE_PATTERN = Pattern.compile("[0-9]+");

    public boolean test(String text) {
        return HOGE_PATTERN.matcher(text).matches(); //Die Bewegung ist Text.maches("[0-9]+")Gleich wie
    }
}

Grundlegende Verwendung

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("[0-9]+");
        
        Matcher abc = pattern.matcher("123abc");
        System.out.println(abc.matches());

        Matcher _123 = pattern.matcher("123");
        System.out.println(_123.matches());
    }
}

Ausführungsergebnis

false
true

• Kompilieren Sie zuerst den regulären Ausdruck mit "Pattern.compile (String)" und rufen Sie die "Pattern" -Instanz ab.
• Übergeben Sie als Nächstes die Zeichenfolge (** Eingabesequenz **), die Sie mit der Methode Pattern.matcher (String) überprüfen möchten, und rufen Sie die Instanz Matcher ab. --Verwenden Sie die erfasste "Matcher" -Instanz, um zu überprüfen, ob sie übereinstimmt oder nicht. --Matcher.matches () überprüft, ob die gesamte Eingabesequenz mit dem regulären Ausdruck übereinstimmt, und gibt das Ergebnis mit boolean zurück

Teilt

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.Arrays;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("[a-z]+");

        String[] elements = pattern.split("123abc456def789ghi");
        System.out.println(Arrays.toString(elements));

        elements = pattern.split("123abc456def789ghi", -1);
        System.out.println(Arrays.toString(elements));
    }
}

Ausführungsergebnis

[123, 456, 789]
[123, 456, 789, ]

• Teilen Sie mit Pattern.split (String) die Zeichenfolge an dem Teil der angegebenen Zeichenfolge auf, der dem regulären Ausdruck entspricht.
• Die Bewegung ist die gleiche wie "String.split (String)", "String.split (String, int)"

Matcher --Pattern ist eine Klasse, die reguläre Ausdrücke interpretiert, und Matcher führt die folgende Verarbeitung durch.

• Ob die Eingabesequenz mit dem regulären Ausdruck übereinstimmt
• Extrahieren des übereinstimmenden Teils
• Austausch von passenden Teilen --Matcher wird in den folgenden Schritten verwendet.

1. Führen Sie eine Übereinstimmungsoperation durch
2. Fragen Sie das Ergebnis der Übereinstimmungsoperation ab
3. Wiederholen Sie gegebenenfalls die Schritte 1 und 2

• Auf das Ergebnis der Übereinstimmungsoperation kann mit der folgenden Methode verwiesen werden. --start () Startindex für übereinstimmende Eingabesequenz --end () Endindex für übereinstimmende Eingabesequenz + 1 --group () Passender Teilstring
• Wenn Sie diese Methoden ausführen, ohne eine Übereinstimmungsoperation auszuführen, wird "IllegalStateException" ausgelöst.
• Beachten Sie, dass "Matcher" nicht threadsicher ist **

Match-Operation

Es gibt drei Match-Operationen in "Matcher".

• matches() --Überprüfen Sie, ob die gesamte Eingabesequenz mit dem regulären Ausdruck übereinstimmt
• lookingAt() --Überprüfen Sie, ob der reguläre Ausdruck mit dem Beginn der Eingabesequenz übereinstimmt
• find() --Überprüfen Sie, ob es einen Teil gibt, der dem regulären Ausdruck in der Eingabesequenz entspricht

matches()

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        test("abc");
        test("abc123");
    }

    private static void test(String text) {
        Pattern pattern = Pattern.compile("[a-z]+");
        Matcher matcher = pattern.matcher(text);

        System.out.println("[text=" + text + "]");
        if (matcher.matches()) {
            System.out.println("matches = true");
            System.out.println("start = " + matcher.start());
            System.out.println("end = " + matcher.end());
            System.out.println("group = " + matcher.group());
        } else {
            System.out.println("matches = false");
        }
    }
}

Ausführungsergebnis

[text=abc]
matches = true
start = 0
end = 3
group = abc

[text=abc123]
matches = false

--matches () überprüft, ob die gesamte Eingabesequenz mit dem regulären Ausdruck übereinstimmt

• Gibt "true" zurück, wenn es übereinstimmt

lookingAt()

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        test("abc");
        test("123abc");
        test("ab12");
    }

    private static void test(String text) {
        Pattern pattern = Pattern.compile("[a-z]+");
        Matcher matcher = pattern.matcher(text);

        System.out.println("[text=" + text + "]");
        if (matcher.lookingAt()) {
            System.out.println("lookingAt = true");
            System.out.println("start = " + matcher.start());
            System.out.println("end = " + matcher.end());
            System.out.println("group = " + matcher.group());
        } else {
            System.out.println("lookingAt = false");
        }
    }
}

Ausführungsergebnis

[text=abc]
lookingAt = true
start = 0
end = 3
group = abc

[text=123abc]
lookingAt = false

[text=ab12]
lookingAt = true
start = 0
end = 2
group = ab

--lookingAt () überprüft, ob der reguläre Ausdruck mit dem Beginn der Eingabesequenz übereinstimmt --Wenn die Überprüfung zu Beginn des Spiels erfolgt, wird "true" zurückgegeben (das Ganze muss nicht übereinstimmen).

find()

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        test("abc");
        test("123abc456def789");
    }

    private static void test(String text) {
        Pattern pattern = Pattern.compile("[a-z]+");
        Matcher matcher = pattern.matcher(text);

        System.out.println("[text=" + text + "]");
        while (matcher.find()) {
            System.out.println("start = " + matcher.start());
            System.out.println("end = " + matcher.end());
            System.out.println("group = " + matcher.group());
        }
    }
}

Ausführungsergebnis

[text=abc]
start = 0
end = 3
group = abc

[text=123abc456def789]
start = 3
end = 6
group = abc

start = 9
end = 12
group = def

• Die Methode find () durchsucht den Anfang der Eingabesequenz nach einer Übereinstimmung mit dem regulären Ausdruck.
• Gibt "true" zurück, wenn ein passender Teilstring vorhanden ist
• Wenn Sie find () erneut ausführen, wird nach einem Teilstring gesucht, der erneut mit dem zuvor übereinstimmenden Teil übereinstimmt.
• Übereinstimmende Teilzeichenfolgen können durch wiederholte Ausführung extrahiert werden --start () ,end (),group ()gibt das Ergebnis der letzten Übereinstimmung zurück

Ersatz

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("[a-z]+");
        Matcher matcher = pattern.matcher("abc123def");

        System.out.println("replaceAll = " + matcher.replaceAll("*"));
        System.out.println("replaceFirst = " + matcher.replaceFirst("*"));
    }
}

Ausführungsergebnis

replaceAll = *123*
replaceFirst = *123def

--Ersetzen Sie alle übereinstimmenden Teilzeichenfolgen durch "Matcher.replaceAll (String)" --Matcher.replaceFirst (String) ersetzt nur den ersten übereinstimmenden Teilstring

Gruppe

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("([a-z]+)([0-9]+)");
        Matcher matcher = pattern.matcher("abc123de45fg");

        int groupCount = matcher.groupCount();
        System.out.println("groupCount=" + groupCount);
        
        while (matcher.find()) {
            System.out.println("==========");
            String group = matcher.group();
            System.out.println("group=" + group);
            
            for (int i=0; i<=groupCount; i++) {
                String g = matcher.group(i);
                System.out.println("group(" + i + ")=" + g);
            }
        }
    }
}

Ausführungsergebnis

groupCount=2
==========
group=abc123
group(0)=abc123
group(1)=abc
group(2)=123
==========
group=de45
group(0)=de45
group(1)=de
group(2)=45

• Die folgenden Methoden beziehen sich auf die durch den regulären Ausdruck definierte Gruppe (den von () eingeschlossenen Teil). --groupCount () Liefert die Anzahl der durch den regulären Ausdruck definierten Gruppen --group () Ruft die gesamte Zeichenfolge ab, die mit der letzten Übereinstimmungsoperation übereinstimmt --group (int) Ruft die Gruppe mit dem angegebenen Index unter den Gruppen ab, die in der letzten Übereinstimmungsoperation übereinstimmen.
• Die Zahl "0" ist die gesamte übereinstimmende Zeichenfolge, daher wird das gleiche Ergebnis wie "group ()" zurückgegeben
• Der Teilstring, der mit 1 übereinstimmt

Geben Sie der Gruppe einen Namen

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("(?<alphabets>[a-z]+)(?<numbers>[0-9]+)");
        Matcher matcher = pattern.matcher("abc123de45fg");
        
        while (matcher.find()) {
            System.out.println("==========");
            System.out.println("group(alphabets)=" + matcher.group("alphabets"));
            System.out.println("group(numbers)=" + matcher.group("numbers"));
        }
    }
}

Ausführungsergebnis

==========
group(alphabets)=abc
group(numbers)=123
==========
group(alphabets)=de
group(numbers)=45

• Sie können einen Namen für eine Gruppe definieren, indem Sie die Gruppe als "(? Muster)" definieren.
• Sie können den Teilstring erhalten, der der Gruppe entspricht, indem Sie den Namen angeben, der durch die Methode group (String) definiert wurde.

Gehen Sie wie folgt vor, um auf den Gruppennamen in der Ersatzzeichenfolge zu verweisen:

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("(?<alphabets>[a-z]+)(?<numbers>[0-9]+)");
        Matcher matcher = pattern.matcher("abc123def456");

        String replaced = matcher.replaceAll("${numbers}${alphabets}");
        System.out.println(replaced);
    }
}

Ausführungsergebnis

123abc456def

• Sie können auf eine Gruppe mit "$ {Gruppenname}" verweisen

Flagge

--Wenn Sie eine "Pattern" -Instanz erstellen, können Sie anpassen, wie der reguläre Ausdruck mit dem ** -Flag ** interpretiert wird.

Kompilieren Sie mit Flags

Pattern pattern = Pattern.compile("[a-z]", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);

• Das Flag wird durch das zweite Argument von compile (String, int) angegeben
• Sie können Konstanten angeben, die in der Klasse "Pattern" als "static" deklariert sind.
• Da es sich um eine Bitmaske handelt, geben Sie mehrere Flags an, indem Sie sie mit | verketten.

CASE_INSENSITIVE (Groß- und Kleinschreibung wird nicht berücksichtigt)

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher("ABC");
        System.out.println(matcher.matches());
    }
}

Ausführungsergebnis

true

• Wenn Sie "CASE_INSENSITIVE" angeben, wird bei der Übereinstimmung die Groß- und Kleinschreibung nicht berücksichtigt.
• Nur US-ASCII-Zeichen sind nicht zu unterscheiden

UNICODE_CASE (Unicode unterscheidet nicht zwischen Groß- und Kleinschreibung)

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("[a-zＡ-Ｚ]+", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher matcher = pattern.matcher("ABCａｂｃ");
        System.out.println(matcher.matches());
    }
}

Ausführungsergebnis

true

• Das Kombinieren von "UNICODE_CASE" und "CASE_INSENSITIVE" ermöglicht eine Übereinstimmung ohne Berücksichtigung der Groß- und Kleinschreibung in Unicode.

LITERAL (keine Metazeichen oder Escapezeichen für reguläre Ausdrücke verwenden)

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        Pattern pattern = Pattern.compile("[a-z]+", Pattern.LITERAL);
        
        Matcher matcher = pattern.matcher("abc");
        System.out.println(matcher.matches());
        
        matcher = pattern.matcher("[a-z]+");
        System.out.println(matcher.matches());
    }
}

Ausführungsergebnis

false
true

• Wenn "LITERAL" angegeben wird, wird die im ersten Argument von "compile (String, int)" übergebene Zeichenfolge als einfache Zeichenfolge verarbeitet.
• Ein Zeichen, das in einem regulären Ausdruck wie "[]" oder "+" von Bedeutung ist, wird einfach als das Zeichen selbst interpretiert.

MULTILINE (verarbeitet mehrzeilige Zeichenfolgen)

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.function.Supplier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        test("[default]", () -> Pattern.compile("^[a-z]+$"));
        test("[MULTILINE]", () -> Pattern.compile("^[a-z]+$", Pattern.MULTILINE));
    }
    
    private static void test(String label, Supplier<Pattern> patternSupplier) {
        System.out.println(label);
        Pattern pattern = patternSupplier.get();

        String text = "abc\n"
                    + "def\n";

        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            String group = matcher.group();
            System.out.println(group);
        }
    }
}

Ausführungsergebnis

[default]
[MULTILINE]
abc
def

• Wenn MULTILINE angegeben ist, ändert sich die Behandlung von ^ und$, die den Anfang und das Ende von Zeilen darstellen.
• Wenn nichts angegeben ist, stimmen ^ und $ nur am Anfang und Ende der Zeichenfolge überein.
• Wenn "MULTILINE" angegeben ist, wird jeder durch einen Zeilenumbruch getrennte als Zeichenfolge verarbeitet, sodass "^" und "$" mit dem Anfang und dem Ende jeder Zeile übereinstimmen.

KOMMENTARE (Ermöglicht das Schreiben von Kommentaren)

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        String regexp = "#Diese Zeile wird als Kommentar ignoriert\n"
                      + "  [a-z]+  ";
        Pattern pattern = Pattern.compile(regexp, Pattern.COMMENTS);

        Matcher matcher = pattern.matcher("abc");

        System.out.println(matcher.matches());
    }
}

Ausführungsergebnis

true

• Wenn "KOMMENTARE" angegeben ist, werden die folgenden Zeichenfolgen als Kommentare behandelt und ignoriert. --Vom # bis zum Ende der Zeile --Leerstelle

DOTALL (stellen Sie sicher, dass das Ende der Zeile mit . übereinstimmt)

package sample.regexp;

import org.openjdk.jmh.runner.RunnerException;

import java.util.function.Supplier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) throws RunnerException {
        test("[default1]", () -> Pattern.compile(".+"));
        test("[default2]", () -> Pattern.compile(".+$"));
        test("[DOTALL]", () -> Pattern.compile(".+", Pattern.DOTALL));
    }

    private static void test(String label, Supplier<Pattern> patternSupplier) {
        System.out.println(label);
        Pattern pattern = patternSupplier.get();

        String text = "abc\n"
                    + "def\n";

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {
            String group = matcher.group();
            System.out.println(group);
        }
    }
}

Ausführungsergebnis

[default1]
abc
[default2]
def
[DOTALL]
abc
def

• Wenn "DOTALL" angegeben ist, stimmt "." Auch am Ende der Zeile überein.
• Standardmäßig stimmt . nicht mit dem Zeilenende überein

Referenz

• Pattern (Java Platform SE 8 )
• Matcher (Java Platform SE 8 )
• Unicode-konform ohne Berücksichtigung der Groß- und Kleinschreibung (UNIX_LINES, (? U)) - Optionsmodifikatoren - Verwendung regulärer Java-Ausdrücke
• Literale Syntaxanalyse von Mustern aktivieren (LITERAL) - Optionale Modifikatoren - Verwendung regulärer Java-Ausdrücke

[^ 1]: Beispielsweise führt die Methode "split (String regexp)" eine geteilte Verarbeitung ohne Verwendung von "Pattern" durch, wenn "regexp" eine einfache Zeichenfolge ist, die keine Metazeichen regulärer Ausdrücke verwendet. Geht