Wie man prüft, ob eine Zeichenkette einem E-Mail-Format in Java entspricht

Einführung

In diesem Lab lernen Sie, wie Sie in Java mithilfe von regulären Ausdrücken überprüfen können, ob eine gegebene Zeichenkette einem Standard-E-Mail-Format entspricht. Wir werden ein geeignetes reguläres Ausdrucks-Muster (regex pattern) definieren, die Methode Pattern.matches() zur Überprüfung nutzen und unsere Implementierung mit verschiedenen gültigen und ungültigen E-Mail-Adressen testen, um sicherzustellen, dass sie korrekt funktioniert. Diese praktische Übung gibt Ihnen praktische Erfahrungen mit Java's Fähigkeiten bei der Übereinstimmung von Zeichenkettenmustern mithilfe von regulären Ausdrücken.

Definieren des E-Mail-Regex-Musters

In diesem Schritt beginnen wir damit, das reguläre Ausdrucks-Muster (regex pattern) zu definieren, das wir zur Überprüfung von E-Mail-Adressen verwenden werden. Reguläre Ausdrücke, oft abgekürzt als "regex" oder "regexp", sind Zeichenfolgen, die ein Suchmuster definieren. Sie sind äußerst leistungsstark für die Mustererkennung und Manipulation von Zeichenketten.

Für die E-Mail-Überprüfung hilft uns ein reguläres Ausdrucks-Muster zu überprüfen, ob eine gegebene Zeichenkette dem Standardformat einer E-Mail-Adresse entspricht (z.B. username@domain.com). Während ein perfekter regulärer Ausdruck für alle möglichen gültigen E-Mail-Adressen sehr komplex ist, können wir ein Muster definieren, das die meisten gängigen und gültigen Formate abdeckt.

Wir werden eine neue Java-Datei erstellen, um unseren Code zu speichern.

Öffnen Sie die WebIDE, wenn sie noch nicht geöffnet ist. Standardmäßig sollten Sie sich im Verzeichnis ~/project befinden.
Klicken Sie im Dateiexplorer links mit der rechten Maustaste in den leeren Bereich und wählen Sie "Neue Datei". Benennen Sie die Datei EmailValidator.java.
Öffnen Sie die Datei EmailValidator.java im Editor, indem Sie darauf im Dateiexplorer klicken.
Fügen wir nun die Grundstruktur unserer Java-Klasse hinzu und definieren das reguläre Ausdrucks-Muster. Kopieren und fügen Sie den folgenden Code in die Datei EmailValidator.java ein:
```
import java.util.regex.Pattern;

public class EmailValidator {

    // Email regex pattern
    private static final String EMAIL_REGEX =
            "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";

    public static void main(String[] args) {
        // We will add code here in the next steps
    }
}
```
Werfen wir kurz einen Blick auf die neuen Teile:
- import java.util.regex.Pattern;: Diese Zeile importiert die Pattern-Klasse, die Teil von Java's integrierter Unterstützung für reguläre Ausdrücke ist.
- private static final String EMAIL_REGEX = "...";: Diese Zeile deklariert eine konstante Variable namens EMAIL_REGEX und weist ihr unser reguläres Ausdrucks-Muster zu.
  - ^: Passt auf den Anfang der Zeichenkette.
  - [a-zA-Z0-9_+&*-]+: Passt auf ein oder mehrere alphanumerische Zeichen oder _, +, &, *, -. Dies ist für den Benutzernamen-Teil.
  - (?:\\.[a-zA-Z0-9_+&*-]+)*: Passt auf null oder mehrere Vorkommen eines Punkts, gefolgt von weiteren Benutzernamen-Zeichen. Dies ermöglicht Punkte im Benutzernamen (z.B. first.last).
  - @: Passt auf das Literal "@"-Symbol.
  - (?:[a-zA-Z0-9-]+\\.)+: Passt auf ein oder mehrere Vorkommen von alphanumerischen Zeichen oder -, gefolgt von einem Punkt. Dies ist für den Domainnamen (z.B. domain.).
  - [a-zA-Z]{2,7}: Passt auf 2 bis 7 alphabetische Zeichen für die Top-Level-Domain (z.B. com, org, Ländercodes).
  - $: Passt auf das Ende der Zeichenkette.
Machen Sie sich keine Sorgen, wenn das reguläre Ausdrucks-Muster kompliziert aussieht. Das Verständnis aller Details komplexer regulärer Ausdrücke benötigt Zeit und Übung. Konzentrieren Sie sich vorerst darauf, dass diese Zeichenkette die Regel für ein gültiges E-Mail-Format definiert.
Speichern Sie die Datei EmailValidator.java (Strg+S oder Cmd+S).

Sie haben nun erfolgreich die Java-Datei erstellt und das reguläre Ausdrucks-Muster für die E-Mail-Überprüfung definiert. Im nächsten Schritt werden wir dieses Muster verwenden, um tatsächliche E-Mail-Adressen zu überprüfen.

Verwendung von Pattern.matches() zur E-Mail-Validierung

In diesem Schritt lernen wir, wie man die Pattern.matches()-Methode in Java verwendet, um zu überprüfen, ob eine gegebene Zeichenkette unserem definierten E-Mail-Regulären Ausdrucks-Muster (regex pattern) entspricht. Die Methode Pattern.matches(regex, input) ist eine bequeme Möglichkeit, eine einfache Übereinstimmung einer gesamten Eingabezeichenkette mit einem regulären Ausdruck durchzuführen. Sie gibt true zurück, wenn die gesamte Eingabezeichenkette dem regulären Ausdruck entspricht, andernfalls false.

Wir werden unserer EmailValidator-Klasse eine neue Methode hinzufügen, um diese Überprüfung durchzuführen.

Öffnen Sie die Datei EmailValidator.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Fügen Sie die folgende Methode innerhalb der EmailValidator-Klasse, aber außerhalb der main-Methode hinzu:
```
public static boolean isValidEmail(String email) {
    return Pattern.matches(EMAIL_REGEX, email);
}
```
Werfen wir einen Blick auf diese neue Methode:
- public static boolean isValidEmail(String email): Dies deklariert eine neue Methode namens isValidEmail.
  - public: Bedeutet, dass diese Methode von außerhalb der Klasse aufgerufen werden kann.
  - static: Bedeutet, dass diese Methode der EmailValidator-Klasse selbst gehört, nicht einem bestimmten Objekt der Klasse. Wir können sie direkt über den Klassennamen aufrufen (z.B. EmailValidator.isValidEmail(...)).
  - boolean: Gibt an, dass diese Methode einen booleschen Wert (true oder false) zurückgibt.
  - (String email): Gibt an, dass die Methode ein Argument entgegennimmt, eine String-Variable namens email, die die E-Mail-Adresse ist, die wir überprüfen möchten.
- return Pattern.matches(EMAIL_REGEX, email);: Dies ist der Kern der Methode. Sie ruft die Pattern.matches()-Methode auf und übergibt unseren EMAIL_REGEX und die Eingabezeichenkette email. Das Ergebnis dieser Übereinstimmung (true oder false) wird dann von unserer isValidEmail-Methode zurückgegeben.
Jetzt ändern wir die main-Methode, um unsere neue isValidEmail-Methode zu verwenden. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:
```
public static void main(String[] args) {
    String testEmail = "test.email@example.com";
    boolean isValid = isValidEmail(testEmail);

    if (isValid) {
        System.out.println(testEmail + " is a valid email address.");
    } else {
        System.out.println(testEmail + " is not a valid email address.");
    }
}
```
In dieser aktualisierten main-Methode:
- String testEmail = "test.email@example.com";: Wir definieren eine Beispiel-E-Mail-Adresse zum Testen.
- boolean isValid = isValidEmail(testEmail);: Wir rufen unsere isValidEmail-Methode mit der testEmail auf und speichern den zurückgegebenen booleschen Wert in der Variable isValid.
- Der if- und else-Block überprüft den Wert von isValid und gibt eine Nachricht aus, die angibt, ob die E-Mail gültig ist oder nicht.
Speichern Sie die Datei EmailValidator.java (Strg+S oder Cmd+S).
Jetzt kompilieren wir unser aktualisiertes Programm. Ö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 EmailValidator.java
```
Wenn keine Fehler auftreten, war die Kompilierung erfolgreich.
Führen Sie schließlich das kompilierte Programm mit dem java-Befehl aus:
```
java EmailValidator
```
Sie sollten eine Ausgabe sehen, die angibt, ob die Test-E-Mail gemäß unserem regulären Ausdrucks-Muster gültig ist.
```
test.email@example.com is a valid email address.
```

Sie haben nun erfolgreich die Pattern.matches()-Methode verwendet, um eine E-Mail-Adresse anhand Ihres definierten regulären Ausdrucks-Musters zu überprüfen. Im nächsten Schritt werden wir mit verschiedenen gültigen und ungültigen E-Mail-Adressen testen.

Testen mit gültigen und ungültigen E-Mail-Adressen

In diesem letzten Schritt werden wir unseren EmailValidator mit einigen Beispielen sowohl von gültigen als auch ungültigen E-Mail-Adressen testen, um zu sehen, wie unser reguläres Ausdrucks-Muster (regex pattern) und die Pattern.matches()-Methode damit umgehen. Dies wird uns helfen, das Verhalten unserer Überprüfungslogik zu verstehen.

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

Ändern Sie die main-Methode, um mehrere E-Mail-Adressen zu testen. Ersetzen Sie die aktuelle main-Methode durch den folgenden Code:

public static void main(String[] args) {
    String[] testEmails = {
        "test.email@example.com",       // Valid
        "another_test+alias@sub.domain.co.uk", // Valid
        "invalid-email",                // Invalid (missing @)
        "invalid@domain",               // Invalid (missing top-level domain)
        "invalid@domain.",              // Invalid (missing top-level domain)
        "invalid@domain.c",             // Invalid (top-level domain too short)
        "invalid@domain.abcdefgh",      // Invalid (top-level domain too long)
        "@domain.com",                  // Invalid (missing username)
        "test@.com"                     // Invalid (missing domain name)
    };

    for (String email : testEmails) {
        boolean isValid = isValidEmail(email);

        if (isValid) {
            System.out.println(email + " is a valid email address.");
        } else {
            System.out.println(email + " is not a valid email address.");
        }
    }
}

In dieser aktualisierten main-Methode:

Wir erstellen ein String-Array namens testEmails, das verschiedene E-Mail-Adressen enthält, sowohl gültige als auch absichtlich ungültige.
Wir verwenden eine for-Schleife, um durch jede E-Mail-Adresse im testEmails-Array zu iterieren.
Innerhalb der Schleife rufen wir für jede email unsere isValidEmail-Methode auf und geben das Ergebnis aus, genau wie wir es im vorherigen Schritt getan haben.

Speichern Sie die Datei EmailValidator.java (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac EmailValidator.java
```
Stellen Sie sicher, dass keine Kompilierungsfehler auftreten.

Führen Sie das kompilierte Programm aus:

java EmailValidator

Beobachten Sie die Ausgabe. Sie sollten für jede E-Mail-Adresse im testEmails-Array eine Zeile sehen, die angibt, ob unser Validator sie basierend auf dem regulären Ausdrucks-Muster als gültig oder ungültig ansieht.

test.email@example.com is a valid email address.
another_test+alias@sub.domain.co.uk is a valid email address.
invalid-email is not a valid email address.
invalid@domain is not a valid email address.
invalid@domain. is not a valid email address.
invalid@domain.c is not a valid email address.
invalid@domain.abcdefgh is not a valid email address.
@domain.com is not a valid email address.
test@.com is not a valid email address.

Durch das Testen mit verschiedenen Eingaben können Sie sehen, wie das reguläre Ausdrucks-Muster und die Pattern.matches()-Methode zusammenarbeiten, um E-Mail-Adressen zu überprüfen. Denken Sie daran, dass obwohl dieser reguläre Ausdruck viele gängige Fälle abdeckt, die Überprüfung aller möglichen E-Mail-Formate gemäß strengen Standards viel komplexer sein kann.

Sie haben nun erfolgreich einen grundlegenden E-Mail-Überprüfungsmechanismus unter Verwendung von Java's Fähigkeiten für reguläre Ausdrücke implementiert und getestet.

Zusammenfassung

In diesem Lab haben wir zunächst unsere Java-Umgebung eingerichtet und eine neue Datei EmailValidator.java erstellt. Anschließend haben wir ein reguläres Ausdrucks-Muster (EMAIL_REGEX) definiert, das speziell für die Überprüfung von E-Mail-Adressen entwickelt wurde. Dieses Muster, das als konstante Zeichenkette gespeichert ist, nutzt die java.util.regex.Pattern-Klasse von Java, um leistungsstarke Zeichenkettenübereinstimmungsmöglichkeiten zu ermöglichen. Dieser erste Schritt legt die Grundlage für die Implementierung der E-Mail-Überprüfungslogik in den folgenden Schritten.