Wie man prüft, ob eine Zeichenkette einem regulären Ausdruck in Java entspricht

Einführung

In diesem Lab lernen Sie, wie Sie überprüfen können, ob eine Zeichenkette einem regulären Ausdruck in Java entspricht. Wir beginnen damit, die Grundlagen von regulären Ausdrücken zu verstehen und wie man ein einfaches Muster mit dem Paket java.util.regex erstellt.

Anschließend werden Sie die Klassen Pattern und Matcher untersuchen, um Übereinstimmungsoperationen auszuführen. Schließlich wenden Sie Ihr Wissen an, um reguläre Ausdrucksmuster mit Benutzereingaben zu testen und so praktische Erfahrungen in der Verwendung von regulären Ausdrücken für die Validierung und Manipulation von Zeichenketten in Java zu sammeln.

Erstellen eines einfachen regex-Musters

In diesem Schritt werden wir zunächst verstehen, was reguläre Ausdrücke (regex) sind und wie man in Java ein einfaches Muster erstellt.

Reguläre Ausdrücke sind leistungsstarke Werkzeuge, die zum Übereinstimmensuchen und Manipulieren von Textzeichenketten verwendet werden. Stellen Sie sich sie als eine Mini-Sprache zur Beschreibung von Mustern in Text vor. Sie sind unglaublich nützlich für Aufgaben wie das Suchen nach spezifischem Text, die Validierung von Eingabeformaten (z. B. E-Mail-Adressen oder Telefonnummern) und das Ersetzen von Text basierend auf Mustern.

In Java werden reguläre Ausdrücke vom Paket java.util.regex behandelt. Die beiden Hauptklassen, die wir verwenden werden, sind Pattern und Matcher.

Pattern: Diese Klasse repräsentiert einen kompilierten regulären Ausdruck. Sie kompilieren eine regex-Zeichenkette in ein Pattern-Objekt.
Matcher: Diese Klasse wird verwendet, um Übereinstimmungsoperationen an einer Eingabezeichenkette durchzuführen, indem ein Pattern interpretiert wird.

Lassen Sie uns ein einfaches Java-Programm erstellen, um ein einfaches regex-Muster zu definieren und auszugeben.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:
```
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Print the pattern
        System.out.println("Our regex pattern is: " + pattern.pattern());
    }
}
```
Schauen wir uns die neuen Teile an:
- import java.util.regex.Pattern;: Diese Zeile importiert die Pattern-Klasse, die wir benötigen, um mit regex zu arbeiten.
- String regexPattern = "Java";: Diese Zeile definiert eine einfache Zeichenkettenvariable regexPattern, die unseren regulären Ausdruck enthält. In diesem Fall ist das Muster einfach das Wort "Java".
- Pattern pattern = Pattern.compile(regexPattern);: Hier kompilieren wir unsere regex-Zeichenkette in ein Pattern-Objekt. Die Methode Pattern.compile() nimmt die regex-Zeichenkette als Argument und gibt ein Pattern-Objekt zurück.
- System.out.println("Our regex pattern is: " + pattern.pattern());: Diese Zeile gibt die ursprüngliche regex-Zeichenkette aus, die zum Erstellen des Pattern-Objekts verwendet wurde. Die Methode pattern() des Pattern-Objekts gibt die regex-Zeichenkette zurück.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt lassen Sie uns unser Programm kompilieren. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie den folgenden Befehl aus:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, wird eine Datei HelloJava.class im Verzeichnis ~/project erstellt.
Führen Sie schließlich das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Our regex pattern is: Java
```
Dies bestätigt, dass unser einfaches regex-Muster erfolgreich definiert und kompiliert wurde. Im nächsten Schritt werden wir dieses Muster verwenden, um Übereinstimmungen in einer gegebenen Zeichenkette zu finden.

Verwendung der Klassen Pattern und Matcher

In diesem Schritt lernen wir, wie wir die Matcher-Klasse zusammen mit unserem Pattern verwenden, um Vorkommen des Musters in einer gegebenen Eingabezeichenkette zu finden.

Wie wir im vorherigen Schritt besprochen haben, repräsentiert die Pattern-Klasse den kompilierten regulären Ausdruck. Die Matcher-Klasse wird verwendet, um tatsächlich Suchoperationen an einer bestimmten Eingabezeichenkette mit diesem kompilierten Muster durchzuführen.

So funktioniert der Prozess im Allgemeinen:

Kompilieren des regulären Ausdrucks: Erstellen Sie ein Pattern-Objekt aus Ihrer regex-Zeichenkette mit Pattern.compile().
Erstellen eines Matchers: Holen Sie sich ein Matcher-Objekt, indem Sie die matcher()-Methode auf dem Pattern-Objekt aufrufen und die Eingabezeichenkette übergeben, in der Sie suchen möchten.
Durchführen der Übereinstimmungsprüfung: Verwenden Sie Methoden des Matcher-Objekts, um Übereinstimmungen zu finden. Häufige Methoden sind find() (um die nächste Übereinstimmung zu finden) und matches() (um zu überprüfen, ob die gesamte Eingabezeichenkette dem Muster entspricht).

Lassen Sie uns unser HelloJava.java-Programm ändern, um einen Matcher zu verwenden, um das Wort "Java" in einem Beispielsatz zu finden.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch den folgenden:
```
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // The input string to search within
        String inputString = "Hello, Java! Welcome to Java programming.";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
        }
    }
}
```
Hier ist, was neu ist:
- import java.util.regex.Matcher;: Wir importieren die Matcher-Klasse.
- String inputString = "Hello, Java! Welcome to Java programming.";: Wir definieren die Zeichenkette, in der wir suchen möchten.
- Matcher matcher = pattern.matcher(inputString);: Wir erstellen ein Matcher-Objekt, indem wir die matcher()-Methode auf unserem pattern-Objekt aufrufen und die inputString übergeben.
- while (matcher.find()) { ... }: Diese Schleife verwendet die find()-Methode des Matcher. Die find()-Methode versucht, die nächste Teilzeichenkette der Eingabezeichenkette zu finden, die dem Muster entspricht. Sie gibt true zurück, wenn eine Übereinstimmung gefunden wird, und false sonst. Die while-Schleife läuft so lange, wie find() true zurückgibt.
- System.out.println("Found match at index: " + matcher.start());: Innerhalb der Schleife gibt matcher.start() den Startindex der übereinstimmenden Teilzeichenkette in der Eingabezeichenkette zurück, wenn eine Übereinstimmung gefunden wird. Wir geben diesen Index aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Searching for pattern: 'Java' in string: 'Hello, Java! Welcome to Java programming.'
Found match at index: 7
Found match at index: 27
```
Diese Ausgabe zeigt, dass unser Programm erfolgreich zwei Vorkommen des Wortes "Java" in der Eingabezeichenkette gefunden hat und den Startindex jeder Übereinstimmung ausgegeben hat.

Sie haben nun erfolgreich die Pattern- und Matcher-Klassen verwendet, um ein bestimmtes Muster in einer Zeichenkette zu finden. Im nächsten Schritt werden wir dieses Programm interaktiv gestalten, indem wir es dem Benutzer ermöglichen, die zu durchsuchende Zeichenkette einzugeben.

Testen von regulären Ausdrücken mit Benutzereingaben

In diesem letzten Schritt machen wir unser regex-Programm interaktiv, indem wir es dem Benutzer ermöglichen, die Zeichenkette einzugeben, in der er suchen möchte. Dies macht das Programm flexibler und zeigt, wie man reguläre Ausdrücke mit Benutzerinteraktionen kombiniert.

Wir verwenden die Scanner-Klasse, die Sie vielleicht aus dem "Your First Java Lab" kennen, um Eingaben vom Benutzer zu lesen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch den folgenden:

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

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a string
        System.out.print("Enter the string to search within: ");
        String inputString = scanner.nextLine();

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        boolean found = false;
        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
            found = true;
        }

        if (!found) {
            System.out.println("No match found.");
        }

        // Close the scanner
        scanner.close();
    }
}

Hier sind die Änderungen, die wir vorgenommen haben:

import java.util.Scanner;: Wir importieren die Scanner-Klasse.
Scanner scanner = new Scanner(System.in);: Wir erstellen ein Scanner-Objekt, um Eingaben von der Konsole zu lesen.
System.out.print("Enter the string to search within: ");: Wir fordern den Benutzer auf, die Zeichenkette einzugeben.
String inputString = scanner.nextLine();: Wir lesen die gesamte Eingabezeile vom Benutzer und speichern sie in der Variable inputString.
Wir haben eine boolean found = false;-Variable und einen if (!found)-Block hinzugefügt, um eine Nachricht auszugeben, wenn keine Übereinstimmungen gefunden werden.
scanner.close();: Wir schließen den Scanner, um Systemressourcen freizugeben.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```

Das Programm wartet nun darauf, dass Sie eine Zeichenkette eingeben. Geben Sie eine Zeichenkette ein, die das Wort "Java" enthält (oder nicht) und drücken Sie Enter.

Beispielsweise, wenn Sie eingeben:

Learning Java is fun!

Die Ausgabe wird sein:

Enter the string to search within: Learning Java is fun!
Searching for pattern: 'Java' in string: 'Learning Java is fun!'
Found match at index: 9

Wenn Sie eingeben:

Python is also great.

Die Ausgabe wird sein:

Enter the string to search within: Python is also great.
Searching for pattern: 'Java' in string: 'Python is also great.'
No match found.

Sie haben nun erfolgreich ein interaktives Java-Programm erstellt, das reguläre Ausdrücke verwendet, um ein Muster in einer vom Benutzer bereitgestellten Zeichenkette zu suchen. Dies ist ein praktisches Beispiel dafür, wie regex in realen Anwendungen eingesetzt werden kann.

Zusammenfassung

In diesem Lab haben wir zunächst die Grundlagen von regulären Ausdrücken (regex) in Java kennengelernt, wobei wir uns auf das Paket java.util.regex konzentriert haben. Wir haben gelernt, dass regex ein leistungsstarkes Werkzeug für die Mustererkennung und -manipulation in Zeichenketten ist und dass die Schlüsselklassen Pattern und Matcher sind. Anschließend haben wir das Erstellen eines einfachen regex-Musters geübt, indem wir eine einfache Zeichenkette definiert und sie mit Pattern.compile() zu einem Pattern-Objekt kompiliert haben. Dadurch haben wir gezeigt, wie man ein einfaches regex-Muster in einem Java-Programm definiert und ausgibt.