Vergleichen von Strings in Java

1. Übersicht

In diesem Artikel werden wir über die verschiedenen Möglichkeiten zum Vergleichen von Strings in Java sprechen .

Da String einer der am häufigsten verwendeten Datentypen in Java ist, ist dies natürlich eine sehr häufig verwendete Operation.

2. String- Vergleich mit String- Klasse

2.1. Verwenden des Vergleichsoperators "=="

Die Verwendung des Operators "==" zum Vergleichen von Textwerten ist einer der häufigsten Fehler, die Java-Anfänger machen. Dies ist falsch, da "==" nur die referenzielle Gleichheit zweier Strings überprüft , dh ob sie auf dasselbe Objekt verweisen oder nicht.

Sehen wir uns ein Beispiel für dieses Verhalten an:

String string1 = "using comparison operator"; String string2 = "using comparison operator"; String string3 = new String("using comparison operator"); assertThat(string1 == string2).isTrue(); assertThat(string1 == string3).isFalse();

Im obigen Beispiel ist die erste Behauptung wahr, da die beiden Variablen auf dasselbe String- Literal verweisen .

Andererseits ist die zweite Behauptung falsch, da string1 mit einem Literal erstellt wird und string3 mit dem neuen Operator erstellt wird - daher verweisen sie auf verschiedene Objekte.

2.2. Verwenden von equals ()

Die String- Klasse überschreibt das von Object geerbte equals () . Diese Methode vergleicht zwei Zeichenfolgen Zeichen für Zeichen und ignoriert deren Adresse.

Es betrachtet sie als gleich, wenn sie gleich lang sind und die Zeichen in derselben Reihenfolge sind:

String string1 = "using equals method"; String string2 = "using equals method"; String string3 = "using EQUALS method"; String string4 = new String("using equals method"); assertThat(string1.equals(string2)).isTrue(); assertThat(string1.equals(string4)).isTrue(); assertThat(string1.equals(null)).isFalse(); assertThat(string1.equals(string3)).isFalse();

In diesem Beispiel sind die Variablen string1, string2 und string4 gleich, da sie unabhängig von ihrer Adresse den gleichen Fall und Wert haben.

Für string3 gibt die Methode false zurück, da zwischen Groß- und Kleinschreibung unterschieden wird.

Wenn eine der beiden Zeichenfolgen null ist , gibt die Methode false zurück.

2.3. Verwenden von equalsIgnoreCase ()

Die equalsIgnoreCase () -Methode gibt einen booleschen Wert zurück. Wie der Name schon sagt, ignoriert diese Methode beim Vergleich von Strings die Groß- und Kleinschreibung in Zeichen :

String string1 = "using equals ignore case"; String string2 = "USING EQUALS IGNORE CASE"; assertThat(string1.equalsIgnoreCase(string2)).isTrue();

2.4. Verwenden von compareTo ()

Die Methode compareTo () gibt einen Wert vom Typ int zurück und vergleicht zwei Zeichenfolgen Zeichen für Zeichen lexikografisch basierend auf einem Wörterbuch oder einer natürlichen Reihenfolge.

Diese Methode gibt 0 zurück, wenn zwei Strings gleich sind oder wenn beide null sind, eine negative Zahl, wenn der erste String vor dem Argument steht, und eine Zahl größer als Null, wenn der erste String nach dem Argument String steht.

Sehen wir uns ein Beispiel an:

String author = "author"; String book = "book"; String duplicateBook = "book"; assertThat(author.compareTo(book)) .isEqualTo(-1); assertThat(book.compareTo(author)) .isEqualTo(1); assertThat(duplicateBook.compareTo(book)) .isEqualTo(0);

2.5. Verwenden von compareToIgnoreCase ()

Die compareToIgnoreCase () ähnelt der vorherigen Methode, ignoriert jedoch den Fall:

String author = "Author"; String book = "book"; String duplicateBook = "BOOK"; assertThat(author.compareToIgnoreCase(book)) .isEqualTo(-1); assertThat(book.compareToIgnoreCase(author)) .isEqualTo(1); assertThat(duplicateBook.compareToIgnoreCase(book)) .isEqualTo(0);

3. String - Vergleich mit Objekten der Klasse

Objects ist eine Utility-Klasse, die eine statische equals () -Methode enthält, die in diesem Szenario nützlich ist, um zwei Strings zu vergleichen .

Die Methode gibt wahr , wenn zwei Strings gleich sind , indem zuerst verglichen sie mit ihrer Adresse , dh „ ==“ . Wenn also beide Argumente null sind , wird true zurückgegeben, und wenn genau ein Argument null ist , wird false zurückgegeben.

Andernfalls ruft es einfach die equals () -Methode der Typklasse des übergebenen Arguments auf - in unserem Fall die class equals () -Methode von String . Bei dieser Methode wird zwischen Groß- und Kleinschreibung unterschieden, da intern die equals () -Methode der String- Klasse aufgerufen wird.

Lassen Sie uns dies testen:

String string1 = "using objects equals"; String string2 = "using objects equals"; String string3 = new String("using objects equals"); assertThat(Objects.equals(string1, string2)).isTrue(); assertThat(Objects.equals(string1, string3)).isTrue(); assertThat(Objects.equals(null, null)).isTrue(); assertThat(Objects.equals(null, string1)).isFalse();

4. String- Vergleich mit Apache Commons

Die Apache Commons-Bibliothek enthält eine Dienstprogrammklasse namens StringUtils für String- bezogene Operationen . Dies hat auch einige sehr nützliche Methoden für den String- Vergleich.

4.1. Verwenden von equals () und equalsIgnoreCase ()

Die equals () -Methode der StringUtils- Klasse ist eine erweiterte Version der String- Klassenmethode equals (), die auch Nullwerte verarbeitet:

assertThat(StringUtils.equals(null, null)) .isTrue(); assertThat(StringUtils.equals(null, "equals method")) .isFalse(); assertThat(StringUtils.equals("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equals("equals method", "EQUALS METHOD")) .isFalse();

Die equalsIgnoreCase () -Methode von StringUtils gibt einen booleschen Wert zurück. Dies funktioniert ähnlich wie equals (), außer dass die Groß- und Kleinschreibung von Zeichen in Strings ignoriert wird :

assertThat(StringUtils.equalsIgnoreCase("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equalsIgnoreCase("equals method", "EQUALS METHOD")) .isTrue();

4.2. Verwenden von equalsAny () und equalsAnyIgnoreCase ()

Das erste Argument der equalsAny () -Methode ist ein String und das zweite ein CharSequence vom Typ mit mehreren Argumenten. Die Methode gibt wahr , wenn eine der anderen gegebenen Strings übereinstimmen gegen den ersten String Fall empfindlich.

Andernfalls wird false zurückgegeben:

assertThat(StringUtils.equalsAny(null, null, null)) .isTrue(); assertThat(StringUtils.equalsAny("equals any", "equals any", "any")) .isTrue(); assertThat(StringUtils.equalsAny("equals any", null, "equals any")) .isTrue(); assertThat(StringUtils.equalsAny(null, "equals", "any")) .isFalse(); assertThat(StringUtils.equalsAny("equals any", "EQUALS ANY", "ANY")) .isFalse();

Die equalsAnyIgnoreCase () -Methode funktioniert ähnlich wie die equalsAny () -Methode, ignoriert jedoch auch das Gehäuse:

assertThat(StringUtils.equalsAnyIgnoreCase("ignore case", "IGNORE CASE", "any")).isTrue();

4.3. Verwenden von compare () und compareIgnoreCase ()

Die compare () -Methode in der StringUtils- Klasse ist eine null-sichere Version der compareTo () -Methode der String- Klasse und verarbeitet Nullwerte , indem ein Nullwert berücksichtigt wird, der kleiner als ein Nicht-Nullwert ist. Zwei Nullwerte werden als gleich angesehen.

Darüber hinaus kann diese Methode verwendet werden, um eine Liste von Zeichenfolgen mit Null- Einträgen zu sortieren :

assertThat(StringUtils.compare(null, null)) .isEqualTo(0); assertThat(StringUtils.compare(null, "abc")) .isEqualTo(-1); assertThat(StringUtils.compare("abc", "bbc")) .isEqualTo(-1); assertThat(StringUtils.compare("bbc", "abc")) .isEqualTo(1);

Die Methode compareIgnoreCase () verhält sich ähnlich, außer dass das Groß- / Kleinschreibung ignoriert wird:

assertThat(StringUtils.compareIgnoreCase("Abc", "bbc")) .isEqualTo(-1); assertThat(StringUtils.compareIgnoreCase("bbc", "ABC")) .isEqualTo(1); assertThat(StringUtils.compareIgnoreCase("abc", "ABC")) .isEqualTo(0);

Die beiden Methoden können auch mit der Option nullIsLess verwendet werden . Dies ist ein drittes boolesches Argument, das entscheidet, ob Nullwerte als kleiner betrachtet werden sollen oder nicht .

Ein Nullwert ist niedriger als ein anderer String, wenn nullIsLess wahr ist, und höher, wenn nullIsLess falsch ist.

Probieren wir es aus:

assertThat(StringUtils.compare(null, "abc", true)) .isEqualTo(-1); assertThat(StringUtils.compare(null, "abc", false)) .isEqualTo(1);

Die compareIgnoreCase () -Methode mit einem dritten booleschen Argument funktioniert ähnlich, außer dass Groß- und Kleinschreibung ignoriert wird.

5. Schlussfolgerung

In diesem kurzen Tutorial haben wir verschiedene Möglichkeiten zum Vergleichen von Strings besprochen .

Und wie immer finden Sie den Quellcode für die Beispiele auf GitHub.