So prüfen Sie, ob ein String in Java Sonderzeichen enthält

Einführung

In diesem Lab lernen Sie, wie Sie in Java mithilfe von regulären Ausdrücken prüfen können, ob ein String Sonderzeichen enthält. Wir beginnen damit, Sonderzeichen mithilfe von Regex-Mustern zu definieren und uns mit gängigen Sonderzeichen und ihrer Verwendung vertraut zu machen.

Nach der Definition der Sonderzeichen werden Sie untersuchen, wie Sie die Methode Pattern.matches() verwenden können, um effizient zu bestimmen, ob ein String eines der definierten Sonderzeichen enthält. Abschließend lernen Sie, wie Sie die Anzahl der Vorkommen von Sonderzeichen in einem gegebenen String zählen können, um ein umfassendes Verständnis der Behandlung von Sonderzeichen in Java zu erhalten.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/StringManipulationGroup(["String Manipulation"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java/StringManipulationGroup -.-> java/regex("RegEx") java/SystemandDataProcessingGroup -.-> java/string_methods("String Methods") subgraph Lab Skills java/regex -.-> lab-559981{{"So prüfen Sie, ob ein String in Java Sonderzeichen enthält"}} java/string_methods -.-> lab-559981{{"So prüfen Sie, ob ein String in Java Sonderzeichen enthält"}} end

Definition von Sonderzeichen mit regulären Ausdrücken

In diesem Schritt lernen wir, wie man in Java Sonderzeichen mithilfe von regulären Ausdrücken (regex) definiert. Reguläre Ausdrücke sind leistungsstarke Werkzeuge für die Mustererkennung in Strings. Sonderzeichen in regex haben spezifische Bedeutungen und werden zur Definition von Mustern verwendet.

Hier sind einige gängige Sonderzeichen in regex:

.: Passt auf ein beliebiges einzelnes Zeichen (außer Zeilenumbruch) zu.
*: Passt auf das vorherige Element null oder mehrmals zu.
+: Passt auf das vorherige Element einmal oder mehrmals zu.
?: Passt auf das vorherige Element null oder einmal zu.
[]: Passt auf ein beliebiges einzelnes Zeichen innerhalb der Klammern zu.
|: Fungiert als OR-Operator.
(): Gruppiert Elemente zusammen.
\: Escaped ein Sonderzeichen, sodass es das eigentliche Zeichen matcht.

Beispielsweise können wir \d verwenden, wenn wir auf eine beliebige Ziffer matchen möchten. Wenn wir auf eine Nicht-Ziffer matchen möchten, verwenden wir \D. Ebenso passt \s auf ein beliebiges Leerzeichen zu, und \S auf ein beliebiges Nicht-Leerzeichen.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu demonstrieren, wie man ein regex-Muster für Sonderzeichen definiert.

Ö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 text = "Hello! This is a test string with some special characters: @#$%^&*()_+";
        // Define a regex pattern to match special characters
        String regex = "[^a-zA-Z0-9\\s]";

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

        System.out.println("Original String: " + text);
        System.out.println("Regex Pattern: " + regex);

        System.out.print("Special characters found: ");
        while (matcher.find()) {
            System.out.print(matcher.group() + " ");
        }
        System.out.println(); // Print a newline at the end
    }
}
```
Lassen Sie uns die neuen Teile dieses Codes verstehen:
- import java.util.regex.Matcher; und import java.util.regex.Pattern;: Diese Zeilen importieren die notwendigen Klassen für die Arbeit mit regulären Ausdrücken in Java.
- String regex = "[^a-zA-Z0-9\\s]";: Diese Zeile definiert unser regex-Muster.
  - []: Dies ist eine Zeichenklasse, was bedeutet, dass es auf ein beliebiges einzelnes Zeichen innerhalb der Klammern passt.
  - ^: Wenn es am Anfang einer Zeichenklasse ([^...]) verwendet wird, negiert es die Klasse, was bedeutet, dass es auf jedes Zeichen passt, das nicht in der Klasse ist.
  - a-zA-Z0-9: Dies passt auf einen beliebigen Kleinbuchstaben (a bis z), einen beliebigen Großbuchstaben (A bis Z) oder eine beliebige Ziffer (0 bis 9) zu.
  - \\s: Dies passt auf ein beliebiges Leerzeichen (Leerzeichen, Tabulator, Zeilenumbruch usw.) zu. Wir verwenden \\, da \ ein Sonderzeichen in Java-Strings ist und escaped werden muss.
  - Somit passt das gesamte Muster [^a-zA-Z0-9\\s] auf jedes Zeichen zu, das kein Buchstabe, keine Ziffer oder kein Leerzeichen ist. Dies sind in diesem Zusammenhang unsere "Sonderzeichen".
- Pattern pattern = Pattern.compile(regex);: Diese Zeile kompiliert das regex-Muster in ein Pattern-Objekt. Das Kompilieren des Musters verbessert die Leistung, wenn Sie dasselbe Muster mehrmals verwenden.
- Matcher matcher = pattern.matcher(text);: Diese Zeile erstellt ein Matcher-Objekt, das verwendet wird, um Match-Operationen auf dem Eingabestring (text) mit dem kompilierten Muster durchzuführen.
- while (matcher.find()): Diese Schleife findet die nächste Teilsequenz der Eingabesequenz, die dem Muster entspricht.
- matcher.group(): Dies gibt die übereinstimmende Teilsequenz zurück.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm mit dem javac-Befehl im Terminal:
```
javac HelloJava.java
```

Führen Sie das kompilierte Programm mit dem java-Befehl aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original String: Hello! This is a test string with some special characters: @#$%^&*()_+
Regex Pattern: [^a-zA-Z0-9\s]
Special characters found: ! : @ ## $ % ^ & * ( ) _ +

Sie haben erfolgreich ein regex-Muster definiert, um Sonderzeichen zu identifizieren, und es in einem Java-Programm verwendet.

Verwendung von `Pattern.matches()` für Sonderzeichen

In diesem Schritt werden wir eine andere Möglichkeit erkunden, reguläre Ausdrücke in Java zu verwenden: die Methode Pattern.matches(). Im Gegensatz zum Matcher-Objekt, das wir im vorherigen Schritt verwendet haben, um alle Vorkommen eines Musters zu finden, überprüft Pattern.matches(), ob der gesamte Eingabestring dem angegebenen regulären Ausdruck entspricht.

Diese Methode ist nützlich, wenn Sie überprüfen möchten, ob ein String einem bestimmten Format entspricht, beispielsweise ob ein Passwort mindestens ein Sonderzeichen enthält oder ob ein Benutzername nur erlaubte Zeichen enthält.

Lassen Sie uns unser HelloJava.java-Programm ändern, um Pattern.matches() zu verwenden, um zu prüfen, ob ein String irgendein Sonderzeichen enthält, basierend auf unserem zuvor definierten regex.

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

public class HelloJava {
    public static void main(String[] args) {
        String text1 = "Hello World";
        String text2 = "Hello World!";
        // Define a regex pattern to check for the presence of special characters
        // This pattern checks if the string contains at least one character that is NOT a letter, digit, or whitespace
        String regex = ".*[^a-zA-Z0-9\\s].*";

        boolean containsSpecial1 = Pattern.matches(regex, text1);
        boolean containsSpecial2 = Pattern.matches(regex, text2);

        System.out.println("String 1: \"" + text1 + "\"");
        System.out.println("Contains special characters? " + containsSpecial1);

        System.out.println("String 2: \"" + text2 + "\"");
        System.out.println("Contains special characters? " + containsSpecial2);
    }
}
```
Schauen wir uns die Änderungen an:
- Wir müssen nur java.util.regex.Pattern; für diese Methode importieren.
- Das regex-Muster lautet jetzt .*[^a-zA-Z0-9\\s].*. Lassen Sie uns dies aufschlüsseln:
  - .*: Dies passt auf ein beliebiges Zeichen (.) null oder mehrmals (*) zu. Das erste .* passt auf alles vor dem Sonderzeichen.
  - [^a-zA-Z0-9\\s]: Dies ist dieselbe Zeichenklasse wie im vorherigen Schritt und passt auf ein einzelnes Sonderzeichen.
  - .*: Dies passt auf ein beliebiges Zeichen (.) null oder mehrmals (*) zu. Das zweite .* passt auf alles nach dem Sonderzeichen.
  - Zusammen bedeutet .*[^a-zA-Z0-9\\s].* "passt auf jeden String, der mindestens ein Zeichen enthält, das kein Buchstabe, keine Ziffer oder kein Leerzeichen ist".
- Pattern.matches(regex, text1): Diese statische Methode der Pattern-Klasse nimmt das regex-Muster und den Eingabestring als Argumente und gibt true zurück, wenn der gesamte String dem Muster entspricht, und false sonst.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm:
```
javac HelloJava.java
```

Führen Sie das Programm aus:

java HelloJava

Sie sollten die folgende Ausgabe sehen:

String 1: "Hello World"
Contains special characters? false
String 2: "Hello World!"
Contains special characters? true

Diese Ausgabe zeigt, dass Pattern.matches() korrekt erkannt hat, dass der zweite String ein Sonderzeichen (!) enthält, während der erste dies nicht tut.

Zählen von Sonderzeichen in einem String

In diesem letzten Schritt werden wir das, was wir über die Definition von regex-Mustern und die Verwendung des Matcher-Objekts gelernt haben, kombinieren, um die Anzahl der Sonderzeichen in einem gegebenen String zu zählen. Dies ist eine praktische Anwendung von regex für die Datenanalyse oder -validierung.

Wir werden dasselbe regex-Muster wie in Schritt 1 ([^a-zA-Z0-9\\s]) verwenden, um Sonderzeichen zu identifizieren, und den String mit dem Matcher durchlaufen, um zu zählen, wie oft das Muster gefunden wird.

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

Ersetzen Sie den vorhandenen Code durch folgenden:

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

public class HelloJava {
    public static void main(String[] args) {
        String text = "This string has 5 special characters: !@#$%";
        // Define a regex pattern to match special characters
        String regex = "[^a-zA-Z0-9\\s]";

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

        int count = 0;
        while (matcher.find()) {
            count++;
        }

        System.out.println("Original String: \"" + text + "\"");
        System.out.println("Regex Pattern: " + regex);
        System.out.println("Number of special characters found: " + count);
    }
}

Hier ist, was im neuen Code passiert:

Wir importieren erneut sowohl die Matcher- als auch die Pattern-Klassen.
Wir verwenden dasselbe regex-Muster [^a-zA-Z0-9\\s], um einzelne Sonderzeichen zu matchen.
Wir initialisieren eine Ganzzahlvariable count mit 0.
Die Schleife while (matcher.find()) durchläuft den String, und jedes Mal, wenn die Methode matcher.find() eine Übereinstimmung für das Muster findet, wird der Code innerhalb der Schleife ausgeführt.
Innerhalb der Schleife erhöhen wir die Variable count um 1 für jedes gefundene Sonderzeichen.
Schließlich geben wir die Gesamtanzahl der Sonderzeichen aus.

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

Führen Sie das Programm aus:

java HelloJava

Sie sollten die folgende Ausgabe sehen:

Original String: "This string has 5 special characters: !@#$%"
Regex Pattern: [^a-zA-Z0-9\s]
Number of special characters found: 5

Die Ausgabe zeigt korrekt, dass es 5 Sonderzeichen im angegebenen String gibt. Sie haben erfolgreich regex und das Matcher-Objekt verwendet, um bestimmte Zeichen in einem String zu zählen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Sonderzeichen mit regulären Ausdrücken (regex) in Java definiert. Wir haben uns mit den gängigen Sonderzeichen in regex und deren Bedeutung beschäftigt, wie ., *, +, ?, [], |, () und \. Wir haben auch gesehen, wie man vordefinierte Zeichenklassen wie \d, \D, \s und \S verwendet.

Anschließend haben wir gelernt, wie man die Methode Pattern.matches() nutzt, um zu prüfen, ob ein String Sonderzeichen enthält, basierend auf einem definierten regex-Muster. Schließlich haben wir untersucht, wie man die Anzahl der Vorkommen von Sonderzeichen in einem String zählt, indem man die Methode Matcher.find() verwendet und durch die Übereinstimmungen iteriert.