Wie man prüft, ob ein String einem anderen String in Java entspricht

Einführung

In diesem Lab werden Sie lernen, wie Sie Strings in Java effektiv vergleichen können. Das Verständnis des String-Vergleichs ist für verschiedene Programmieraufgaben von grundlegender Bedeutung. Wir werden die Standard-Methode equals() untersuchen, um zu prüfen, ob zwei Strings die gleiche Zeichenfolge haben, auch wenn sie unterschiedliche Objekte im Speicher sind.

Darüber hinaus werden Sie lernen, wie Sie potenzielle NullPointerException-Probleme behandeln können, wenn Sie Strings vergleichen, die möglicherweise null sind. Abschließend werden wir die Methode equalsIgnoreCase() behandeln, die es Ihnen ermöglicht, Groß- und Kleinschreibung ignorierende String-Vergleiche durchzuführen. Dies bietet Flexibilität, wenn die Groß- und Kleinschreibung der Zeichen für Ihre Vergleichslogik keine Rolle spielt.

Vergleichen von Strings mit der equals()-Methode

In diesem Schritt werden wir lernen, wie man Strings in Java mit der equals()-Methode vergleicht. Das Vergleichen von Strings ist eine grundlegende Operation in der Programmierung, und es ist wichtig, zu verstehen, wie man es richtig macht.

In Java sind Strings Objekte, keine primitiven Datentypen wie Integer oder Booleans. Das bedeutet, dass wenn Sie Strings vergleichen, Sie die Objekte selbst vergleichen, nicht nur ihre Werte. Wenn Sie den ==-Operator verwenden, um Strings zu vergleichen, wird geprüft, ob die beiden String-Variablen auf dasselbe Objekt im Speicher verweisen. Oft möchten Sie jedoch prüfen, ob zwei Strings dieselbe Zeichenfolge haben, auch wenn es unterschiedliche Objekte sind. Hierfür sollten Sie die equals()-Methode verwenden.

Erstellen wir ein einfaches Java-Programm, um dies zu demonstrieren.

Ö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:
```
public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));
    }
}
```
In diesem Code:
- Wir deklarieren drei String-Variablen: str1, str2 und str3.
- str1 und str2 werden mit String-Literalen erstellt. Java optimiert oft String-Literale, so dass identische Literale auf dasselbe Objekt verweisen.
- str3 wird mit dem new String()-Konstruktor erstellt, der explizit ein neues String-Objekt im Speicher erstellt, auch wenn sein Inhalt derselbe wie bei bestehenden Literalen ist.
- Wir verwenden equals(), um den Inhalt der Strings zu vergleichen.
- Wir verwenden ==, um zu prüfen, ob die String-Variablen auf dasselbe Objekt verweisen.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt kompilieren wir unser 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 StringComparison.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe. Eine Datei StringComparison.class wird im Verzeichnis ~/project erstellt.
Führen Sie schließlich das kompilierte Programm mit dem java-Befehl aus:
```
java StringComparison
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
```
Beachten Sie, dass str1.equals(str2) und str1.equals(str3) beide true zurückgeben, weil der Inhalt der Strings derselbe ist. Allerdings gibt str1 == str3 false zurück, weil str1 und str3 auf unterschiedliche String-Objekte im Speicher verweisen, auch wenn sie dieselben Zeichen enthalten. str1 == str2 gibt in diesem speziellen Fall true zurück, aufgrund der String-Literal-Optimierung. Das Verwenden von == für den String-Vergleich wird jedoch im Allgemeinen abgeraten, da es zu unerwarteten Ergebnissen führen kann.

Dies zeigt, warum die Verwendung der equals()-Methode der richtige Weg ist, um den Inhalt von Strings in Java zu vergleichen.

Behandlung von null-Strings bei Gleichheitsüberprüfungen

In diesem Schritt werden wir untersuchen, wie man null-Strings bei Gleichheitsüberprüfungen in Java behandelt. Ein null-String bedeutet, dass die String-Variable auf kein Objekt verweist. Wenn Sie versuchen, eine Methode auf einer null-Variablen aufzurufen, wird eine NullPointerException ausgelöst, was ein häufiger Fehler in Java ist.

Beim Vergleichen von Strings ist es wichtig, die Möglichkeit zu berücksichtigen, dass einer oder beide Strings null sein könnten. Wenn Sie die equals()-Methode auf einem null-String aufrufen, stürzt Ihr Programm ab.

Ändern wir unser vorheriges Programm, um zu sehen, wie dies funktioniert und wie man es sicher handhaben kann.

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

Ändern Sie die main-Methode, um einen null-String einzubeziehen:

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = null; // This string is null

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));

        // Let's try comparing with the null string
        // System.out.println("Comparing str1 and str4 using equals(): " + str1.equals(str4)); // This line would cause a NullPointerException
        // System.out.println("Comparing str4 and str1 using equals(): " + str4.equals(str1)); // This line would also cause a NullPointerException

        // Correct way to compare when one string might be null
        System.out.println("Comparing str1 and str4 safely: " + (str1 != null && str1.equals(str4)));
        System.out.println("Comparing str4 and str1 safely: " + (str4 != null && str4.equals(str1)));
        System.out.println("Comparing str4 and null safely: " + (str4 == null));
    }
}

Im geänderten Code:

Wir haben einen null-String str4 hinzugefügt.
Wir haben die Zeilen auskommentiert, die eine NullPointerException auslösen würden, wenn sie ausgeführt würden.
Wir haben Beispiele hinzugefügt, wie man Strings sicher vergleichen kann, wenn einer von ihnen null sein könnte. Der sicherste Weg ist, zu prüfen, ob der String, auf dem Sie equals() aufrufen, nicht null ist, bevor Sie die Methode aufrufen. Ein gängiges Muster ist (stringVariable != null && stringVariable.equals(anotherString)). Alternativ können Sie, wenn möglich, equals() auf dem bekannten nicht-null-String aufrufen, wie "hello".equals(str4).

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

Führen Sie das kompilierte Programm aus:

java StringComparison

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
Comparing str1 and str4 safely: false
Comparing str4 and str1 safely: false
Comparing str4 and null safely: true

Die Ausgabe zeigt, dass die sicheren Vergleiche den null-String korrekt behandeln, ohne einen Fehler zu verursachen. Der Vergleich zwischen str1 und str4 (der null ist) ergibt korrekt false.

Dieser Schritt hebt die Wichtigkeit des Umgangs mit null-Werten bei der Arbeit mit Objekten in Java, insbesondere Strings, hervor, um NullPointerException-Fehler zu vermeiden.

Verwendung von equalsIgnoreCase() für die größenunabhängige Vergleichsoperation

In diesem letzten Schritt werden wir uns mit der equalsIgnoreCase()-Methode befassen, die dazu dient, Strings ohne Berücksichtigung der Groß- und Kleinschreibung der Zeichen zu vergleichen. Dies ist sehr nützlich, wenn Sie prüfen möchten, ob zwei Strings gleich sind, unabhängig davon, ob die Buchstaben groß oder klein geschrieben sind.

Die equals()-Methode, die wir in den vorherigen Schritten verwendet haben, führt einen groß-/kleinschreibungssensitiven Vergleich durch. Das bedeutet, dass "hello" nicht gleich "Hello" ist, wenn Sie equals() verwenden. Die equalsIgnoreCase()-Methode ignoriert die Groß- und Kleinschreibung, sodass "hello" und "Hello" als gleich betrachtet werden.

Ändern wir unser Programm ein letztes Mal, um equalsIgnoreCase() zu demonstrieren.

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

Fügen Sie einige neue String-Variablen mit unterschiedlicher Groß- und Kleinschreibung hinzu und verwenden Sie equalsIgnoreCase(), um sie zu vergleichen:

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = null;
        String str5 = "Hello"; // Different casing
        String str6 = "HELLO"; // All uppercase

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));

        // Safe comparison with null
        System.out.println("Comparing str1 and str4 safely: " + (str1 != null && str1.equals(str4)));
        System.out.println("Comparing str4 and str1 safely: " + (str4 != null && str4.equals(str1)));
        System.out.println("Comparing str4 and null safely: " + (str4 == null));

        System.out.println("\n--- Case-Insensitive Comparisons ---");
        System.out.println("Comparing str1 and str5 using equals(): " + str1.equals(str5));
        System.out.println("Comparing str1 and str5 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str5));
        System.out.println("Comparing str1 and str6 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str6));
        System.out.println("Comparing str5 and str6 using equalsIgnoreCase(): " + str5.equalsIgnoreCase(str6));

        // equalsIgnoreCase() also handles null safely if called on a non-null string
        System.out.println("Comparing str1 and str4 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str4));
        // System.out.println("Comparing str4 and str1 using equalsIgnoreCase(): " + str4.equalsIgnoreCase(str1)); // This would still cause a NullPointerException
    }
}

Im aktualisierten Code:

Wir haben str5 und str6 mit unterschiedlicher Groß- und Kleinschreibung hinzugefügt.
Wir haben neue Ausgabebefehle hinzugefügt, um den Unterschied zwischen equals() und equalsIgnoreCase() zu demonstrieren.
Wir zeigen auch, dass das Aufrufen von equalsIgnoreCase() auf einem nicht-null-String mit einem null-Argument keinen Fehler verursacht, ähnlich wie bei equals(). Allerdings führt das Aufrufen von equalsIgnoreCase() auf einer null-String-Variablen immer noch zu einer NullPointerException.

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

Führen Sie das kompilierte Programm aus:

java StringComparison

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
Comparing str1 and str4 safely: false
Comparing str4 and str1 safely: false
Comparing str4 and null safely: true

--- Case-Insensitive Comparisons ---
Comparing str1 and str5 using equals(): false
Comparing str1 and str5 using equalsIgnoreCase(): true
Comparing str1 and str6 using equalsIgnoreCase(): true
Comparing str5 and str6 using equalsIgnoreCase(): true
Comparing str1 and str4 using equalsIgnoreCase(): false

Die Ausgabe zeigt deutlich, dass equalsIgnoreCase() true zurückgibt, wenn Strings mit denselben Zeichen, aber unterschiedlicher Groß- und Kleinschreibung verglichen werden, während equals() false zurückgibt.

Sie haben nun gelernt, wie man Strings in Java mit equals() für einen groß-/kleinschreibungssensitiven Vergleich vergleicht, wie man null-Strings sicher behandelt und wie man equalsIgnoreCase() für einen groß-/kleinschreibung-unabhängigen Vergleich verwendet. Dies sind essentielle Fähigkeiten für die Arbeit mit Strings in Java.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Strings in Java vergleicht. Wir haben zunächst den Unterschied zwischen dem Vergleich von String-Objekten mit dem ==-Operator und dem Vergleich ihres Inhalts mit der equals()-Methode verstanden. Wir haben gesehen, dass == die Objektidentität prüft, während equals() die Gleichheit der Zeichenfolge prüft.

Anschließend haben wir untersucht, wie man potenzielle NullPointerException beim Vergleichen von Strings vermeiden kann, indem man sicherstellt, dass der String, auf dem equals() aufgerufen wird, nicht null ist. Schließlich haben wir gelernt, wie man groß-/kleinschreibung-unabhängige String-Vergleiche mit der equalsIgnoreCase()-Methode durchführt.