So prüfen Sie, ob eine Zeichenkette einem Telefonnummerformat in Java entspricht

Einführung

In diesem Lab lernen Sie, wie Sie in Java mithilfe von regulären Ausdrücken (Regular Expressions, Regex) prüfen können, ob eine Zeichenkette einem Telefonnummerformat entspricht. Wir beginnen damit, ein Regex-Muster zu erstellen, das speziell für die Übereinstimmung mit gängigen Telefonnummerformaten ausgelegt ist.

Anschließend validieren Sie eine gegebene Telefonnummer-Zeichenkette anhand des erstellten Regex-Musters mithilfe der Matcher-Klasse von Java. Abschließend werden Sie untersuchen, wie Sie verschiedene Variationen von Telefonnummerformaten verarbeiten und abgleichen können, indem Sie das Regex-Muster anpassen.

Telefonnummer-Regex erstellen

In diesem Schritt lernen wir etwas über reguläre Ausdrücke (Regular Expressions, Regex) und wie man einen erstellt, um Telefonnummern zu matchen. Regex ist ein leistungsstarkes Werkzeug für die Mustererkennung in Zeichenketten. Es ist wie eine spezielle Sprache zur Beschreibung von Textmustern.

Warum benötigen wir Regex für Telefonnummern? Telefonnummern können in vielen Formaten auftreten (z.B. 123-456-7890, (123) 456-7890, 123.456.7890). Mit Regex können wir ein Muster definieren, das all diesen Variationen entspricht.

Lassen Sie uns ein einfaches Java-Programm erstellen, das Regex verwendet, um zu prüfen, ob eine Zeichenkette wie eine Telefonnummer aussieht.

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

public class HelloJava {
    public static void main(String[] args) {
        String phoneNumber = "123-456-7890"; // Die zu prüfende Zeichenkette
        String regex = "\\d{3}-\\d{3}-\\d{4}"; // Das Regex-Muster

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(phoneNumber);

        boolean isMatch = matcher.matches();

        if (isMatch) {
            System.out.println(phoneNumber + " ist ein gültiges Telefonnummerformat.");
        } else {
            System.out.println(phoneNumber + " ist kein gültiges Telefonnummerformat.");
        }
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- import java.util.regex.Matcher; und import java.util.regex.Pattern;: Diese Zeilen importieren die notwendigen Klassen für die Arbeit mit Regex in Java.
- String phoneNumber = "123-456-7890";: Dies ist die Zeichenkette, die wir testen möchten.
- String regex = "\\d{3}-\\d{3}-\\d{4}";: Dies ist unser erstes Regex-Muster. Lassen Sie uns es zerlegen:
  - \\d: Passt auf jede Ziffer (0 - 9) an. Wir verwenden \\, weil \ ein Sonderzeichen in Java-Zeichenketten ist, also müssen wir es escapen.
  - {3}: Passt auf das vorherige Element genau 3 Mal an.
  - -: Passt auf das Bindestrich-Zeichen literal an.
  - Somit passt \\d{3}-\\d{3}-\\d{4} auf drei Ziffern, gefolgt von einem Bindestrich, gefolgt von drei Ziffern, gefolgt von einem Bindestrich, gefolgt von vier Ziffern an.
- Pattern pattern = Pattern.compile(regex);: Dies kompiliert die Regex-Zeichenkette in ein Pattern-Objekt, das für wiederholte Übereinstimmungen effizienter ist.
- Matcher matcher = pattern.matcher(phoneNumber);: Dies erstellt ein Matcher-Objekt, das die Übereinstimmungsoperation auf unserer phoneNumber-Zeichenkette mithilfe des kompilierten pattern durchführt.
- boolean isMatch = matcher.matches();: Dies versucht, die gesamte Eingabezeichenkette (phoneNumber) mit dem Muster zu vergleichen. Es gibt true zurück, wenn die gesamte Zeichenkette übereinstimmt, und false sonst.
- Der if- und else-Block gibt einfach eine Nachricht aus, je nachdem, ob die Zeichenkette mit dem Muster übereinstimmt.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, wird eine HelloJava.class-Datei erstellt.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten die Ausgabe sehen, die angibt, dass "123-456-7890" ein gültiges Telefonnummerformat gemäß unserem einfachen Regex ist.

In diesem Schritt haben Sie die Grundlagen der Verwendung von Regex in Java gelernt und ein einfaches Muster erstellt, um ein bestimmtes Telefonnummerformat zu matchen. In den nächsten Schritten werden wir unser Regex flexibler gestalten, um verschiedene Formate zu verarbeiten.

Telefonnummer mit Matcher validieren

Im vorherigen Schritt haben wir ein einfaches Regex-Muster erstellt und die matches()-Methode der Matcher-Klasse verwendet, um zu prüfen, ob eine gesamte Zeichenkette mit dem Muster übereinstimmt. In diesem Schritt werden wir die Matcher-Klasse weiter untersuchen und sehen, wie sie funktioniert.

Die Matcher-Klasse ist die Engine, die die Übereinstimmungsoperationen durchführt. Sie wird aus einem Pattern-Objekt erstellt und wird verwendet, um Vorkommen des Musters in einer Eingabezeichenkette zu finden.

Lassen Sie uns unser Programm ändern, um eine andere Zeichenkette zu testen und zu sehen, wie die matches()-Methode verhält.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ändern Sie die phoneNumber-Zeichenkette in etwas, das nicht genau mit unserem aktuellen Muster \\d{3}-\\d{3}-\\d{4} übereinstimmt. Beispielsweise ändern Sie die Zeile:
```
String phoneNumber = "123-456-7890"; // The string to check
```
in:
```
String phoneNumber = "My phone number is 123-456-7890."; // The string to check
```
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
```
Diesmal sollte die Ausgabe wie folgt lauten:
```
My phone number is 123-456-7890. is not a valid phone number format.
```
Warum hat das passiert? Weil die matches()-Methode versucht, die gesamte Eingabezeichenkette mit dem Muster zu vergleichen. Da unsere Eingabezeichenkette mehr als nur das Telefonnummer-Muster enthält, gibt matches() false zurück.

Wenn wir herausfinden wollten, ob das Muster irgendwo in der Zeichenkette vorkommt, würden wir eine andere Methode wie find() verwenden, die wir später untersuchen werden. Vorerst konzentrieren wir uns darauf, zu validieren, ob die gesamte Zeichenkette einem bestimmten Format entspricht, indem wir matches() verwenden.

Das Verständnis des Unterschieds zwischen matches() und find() ist von entscheidender Bedeutung, wenn man mit Regex in Java arbeitet. matches() dient zur strengen Validierung der gesamten Zeichenkette, während find() zum Suchen des Musters in einer größeren Zeichenkette verwendet wird.

In diesem Schritt haben Sie gesehen, wie die matches()-Methode der Matcher-Klasse funktioniert und warum es wichtig ist, ihr Verhalten beim Validieren von Zeichenkettenformaten zu verstehen.

Verschiedene Telefonformate verarbeiten

In der realen Welt folgen Telefonnummern nicht immer genau dem Format XXX-XXX-XXXX. Sie können Punkte (.), Leerzeichen (``) oder sogar Klammern (()) verwenden. In diesem Schritt werden wir unser Regex-Muster ändern, um einige dieser Variationen zu berücksichtigen.

Wir werden einige weitere Regex-Konzepte einführen, um unser Muster flexibler zu gestalten:

?: Macht das vorherige Element optional (0 oder 1 Mal).
*: Passt auf das vorherige Element null oder mehr Mal an.
+: Passt auf das vorherige Element ein oder mehr Mal an.
[]: Definiert eine Zeichensammlung. Passt auf ein einzelnes Zeichen innerhalb der Klammern an.
|: Fungiert als OR-Operator. Passt entweder auf das Muster vor oder nach dem | an.

Lassen Sie uns die Datei HelloJava.java aktualisieren, um ein flexibleres Regex-Muster zu verwenden.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ändern Sie die regex-Zeichenkette wie folgt:
```
String regex = "\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}"; // More flexible regex pattern
```
Lassen Sie uns dieses neue Muster zerlegen:
- \\(?: Passt auf eine optionale öffnende Klammer ( an. Wir benötigen \\, um die Sonderbedeutung von ( in Regex zu escapen, und ? macht es optional.
- \\d{3}: Passt genau auf drei Ziffern an.
- \\)?: Passt auf eine optionale schließende Klammer ) an.
- [-.\\s]?: Dies ist eine Zeichensammlung [], die entweder auf einen Bindestrich (-), einen Punkt (.), oder ein Leerzeichen (\\s) passt. Das ? macht diesen Trenner optional.
- \\d{3}: Passt genau auf drei Ziffern an.
- [-.\\s]?: Passt erneut auf einen optionalen Bindestrich, Punkt oder Leerzeichen-Trenner an.
- \\d{4}: Passt genau auf vier Ziffern an.
Dieses Muster kann jetzt Formate wie 123-456-7890, (123) 456-7890, 123.456.7890, 123 456 7890 und sogar 1234567890 (ohne Trennzeichen) matchen.

Jetzt lassen Sie uns dieses neue Muster mit verschiedenen Telefonnummerformaten testen. Ersetzen Sie die phoneNumber-Zeichenkette durch einige verschiedene Beispiele:

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

public class HelloJava {
    public static void main(String[] args) {
        String[] phoneNumbers = {
            "123-456-7890",
            "(123) 456-7890",
            "123.456.7890",
            "123 456 7890",
            "1234567890",
            "invalid-number", // This should not match
            "123-456-789" // This should not match
        };

        String regex = "\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}"; // More flexible regex pattern

        Pattern pattern = Pattern.compile(regex);

        for (String phoneNumber : phoneNumbers) {
            Matcher matcher = pattern.matcher(phoneNumber);
            boolean isMatch = matcher.matches();

            if (isMatch) {
                System.out.println(phoneNumber + " is a valid phone number format.");
            } else {
                System.out.println(phoneNumber + " is not a valid phone number format.");
            }
        }
    }
}

Wir haben ein String-Array phoneNumbers eingeführt, um mehrere Eingaben einfach zu testen, und eine for-Schleife, um durch sie zu iterieren.

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

Führen Sie das kompilierte Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die zeigt, welche Zeichenketten mit dem Muster übereinstimmen:

123-456-7890 is a valid phone number format.
(123) 456-7890 is a valid phone number format.
123.456.7890 is a valid phone number format.
123 456 7890 is a valid phone number format.
1234567890 is a valid phone number format.
invalid-number is not a valid phone number format.
123-456-789 is not a valid phone number format.

Sie haben jetzt ein robusteres Regex-Muster erstellt, das mehrere gängige Telefonnummerformate verarbeiten kann. Dies zeigt die Stärke und Flexibilität von Regex bei der Validierung und Analyse von Zeichenketten.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java mithilfe von regulären Ausdrücken (Regular Expressions, Regex) prüft, ob eine Zeichenkette einem Telefonnummerformat entspricht. Wir haben zunächst das Konzept von Regex und seine Wichtigkeit für die Mustererkennung verstanden, insbesondere für die Verarbeitung verschiedener Telefonnummerformate. Anschließend haben wir ein einfaches Java-Programm erstellt, das das Paket java.util.regex nutzt.

Im ersten Schritt haben wir ein einfaches Regex-Muster \\d{3}-\\d{3}-\\d{4} erstellt, um das Format "XXX-XXX-XXXX" zu matchen. Wir haben Pattern.compile() verwendet, um den Regex in ein Pattern-Objekt zu kompilieren, und Pattern.matcher() verwendet, um ein Matcher-Objekt für die Eingabezeichenkette zu erstellen. Schließlich haben wir matcher.matches() verwendet, um zu prüfen, ob die gesamte Zeichenkette mit dem Muster übereinstimmt, und das Ergebnis ausgegeben. Dies hat die Grundlage für die Validierung von Telefonnummern mit Regex in Java gelegt.