Umfassende Anleitung zum Vergleich von Strings in Java | Unterschiede und Einsatz von ==, equals und compareTo

1. Einführung

Warum ist das Vergleichen von Strings in Java wichtig?

In der Java-Programmierung gibt es sehr viele Situationen, in denen Strings (Zeichenketten) verwendet werden. Überprüfung von Benutzernamen, Abgleich von Eingabewerten aus Formularen, Überprüfung von API-Antworten usw. – in allen möglichen Szenarien wird ein Vergleich von Strings benötigt.

An diesem Punkt ist es überraschend, dass Anfänger oft an der Frage „Wie vergleicht man Strings korrekt?“ scheitern. Insbesondere, wenn man den Unterschied zwischen dem ==-Operator und der equals()-Methode nicht versteht, kann dies zu Bugs mit unerwarteten Ergebnissen führen.

Die Unkenntnis des Unterschieds zwischen „==“ und „equals“ ist gefährlich

Schauen Sie sich beispielsweise den folgenden Code an.

String a = "apple";
String b = new String("apple");

System.out.println(a == b);       // 結果: false
System.out.println(a.equals(b));  // 結果: true

Viele werden vom Ausgabergebnis dieses Codes überrascht sein. Obwohl es sich um dieselbe Zeichenkette handelt, ergibt == false und equals() true. Das liegt daran, dass Java Strings als Referenztyp behandelt, und == die Referenzadressen vergleicht.

Auf diese Weise hängt eine korrekte String-Vergleichung direkt mit der Zuverlässigkeit und Lesbarkeit des Programms zusammen. Umgekehrt kann man durch das Verständnis der richtigen Methode Bugs im Vorfeld vermeiden.

Was man in diesem Artikel lernt

In diesem Artikel erklären wir die Methoden zum Vergleichen von Strings in Java detailliert, von den Grundlagen bis zu fortgeschrittenen Themen. Wir beantworten Fragen wie die folgenden und erklären sie strukturiert und für Anfänger verständlich.

• Was ist der Unterschied zwischen == und equals()?
• Wie vergleicht man ohne Berücksichtigung von Groß- und Kleinschreibung?
• Wie vergleicht man Strings in lexikalischer Reihenfolge?
• Wie vermeidet man Ausnahmen beim Vergleich mit null?

Lassen Sie uns mit praktischen Code-Beispielen, die auch im Berufsalltag nützlich sind, das Wissen über korrekte String-Vergleiche fest verankern.

2. Grundlagen von Strings in Java

Strings sind ein „Referenztyp“

In Java ist der String-Typ kein primitiver Typ (wie int oder boolean), sondern ein „Referenztyp (Reference Type)“. Das bedeutet, dass eine String-Variable nicht die eigentlichen String-Daten selbst speichert, sondern auf ein String-Objekt verweist, das im Heap-Speicher existiert.

Das heißt, wenn man so schreibt:

String a = "hello";
String b = "hello";

dass a und b auf denselben String "hello" verweisen, kann a == b true zurückgeben. Allerdings hängt das von der String-Interning-Optimierung in Java ab.

Der Unterschied zwischen String-Literalen und new String()

In Java werden identische String-Literale mehrmals verwendet, wenn sie als dieselbe Referenz optimiert werden. Das ist eine Funktion, die Java zur Speichereffizienz zur Laufzeit Strings teilt.

String s1 = "apple";
String s2 = "apple";
System.out.println(s1 == s2); // true（同じリテラルなので同一参照）

Andererseits wird bei der expliziten Erstellung eines Objekts mit dem new-Schlüsselwort eine neue Referenz erstellt.

String s3 = new String("apple");
System.out.println(s1 == s3); // false（異なる参照）
System.out.println(s1.equals(s3)); // true（内容は同じ）

Auf diese Weise prüft == die Übereinstimmung der Referenzen, während equals() die Übereinstimmung des Inhalts überprüft, was ihre Anwendungen stark unterscheidet.

String ist eine „unveränderliche (immutable)“ Klasse

Eine weitere wichtige Eigenschaft ist, dass String immutable (unveränderlich) ist. Das bedeutet, dass der Inhalt eines einmal erstellten String-Objekts nicht geändert werden kann.

Wenn man beispielsweise so schreibt:

String original = "hello";
original = original + " world";

sieht es so aus, als würde man dem ursprünglichen original einen String hinzufügen, aber tatsächlich wird ein neues String-Objekt erstellt und diesem original zugewiesen.

Diese Unveränderlichkeit macht String thread-sicher und hilft bei Sicherheit und Cache-Optimierung.

3. Methoden zum Vergleichen von Strings

Referenzvergleich mit dem ==-Operator

== vergleicht die Referenzen (Adressen) der String-Objekte. Selbst wenn der Inhalt gleich ist, gibt es bei unterschiedlichen Objekten false zurück.

String a = "Java";
String b = new String("Java");

System.out.println(a == b);        // false

In diesem Beispiel ist a ein Literal und b mit new erstellt, sodass die Referenzen unterschiedlich sind und false zurückgegeben wird. Es eignet sich nicht für Inhaltsvergleiche, also Vorsicht!

Inhaltsvergleich mit der equals()-Methode

equals() ist die korrekte Methode, um den Inhalt von Strings zu vergleichen. Sie wird in den meisten Fällen empfohlen.

String a = "Java";
String b = new String("Java");

System.out.println(a.equals(b));   // true

So gibt es auch bei unterschiedlichen Referenzen true zurück, wenn der Inhalt gleich ist.

Vorsichtsmaßnahmen beim Vergleich mit null

Der folgende Code kann eine NullPointerException verursachen.

String input = null;
System.out.println(input.equals("test")); // 例外発生！

Um das zu vermeiden, wird empfohlen, in der Form Konstante.equals(Variable) zu schreiben.

System.out.println("test".equals(input)); // false（安全）

Vergleich ohne Berücksichtigung von Groß- und Kleinschreibung mit equalsIgnoreCase()-Methode

Für Benutzernamen oder E-Mail-Adressen, bei denen Groß- und Kleinschreibung ignoriert werden soll, ist equalsIgnoreCase() praktisch.

String a = "Hello";
String b = "hello";

System.out.println(a.equalsIgnoreCase(b)); // true

Allerdings kann es in einigen speziellen Fällen mit Unicode (z. B. dem türkischen „İ“) zu unerwartetem Verhalten kommen, daher ist bei Internationalisierung zusätzliche Vorsicht geboten.

Lexikalischer Vergleich mit der compareTo()-Methode

compareTo() vergleicht zwei Strings lexikalisch und gibt einen Integer-Wert zurück wie folgt:

• 0: Gleich
• Negativer Wert: Der aufrufende String ist vorne (kleiner)
• Positiver Wert: Der aufrufende String ist hinten (größer)

  String a = "apple";
  String b = "banana";
  
  System.out.println(a.compareTo(b)); // 負の値（"apple"は"banana"より前）
  

Es wird häufig für lexikalische Sortierungen oder Filterverarbeitung verwendet und intern in Collections.sort() oder beim Schlüsselvergleich in TreeMap genutzt.

4. Praktische Anwendungsfälle

Abgleich von Benutzereingaben (Login-Funktion)

Einer der häufigsten Anwendungsfälle ist die Übereinstimmungsprüfung von Benutzernamen oder Passwörtern.

String inputUsername = "Naohiro";
String registeredUsername = "naohiro";

if (registeredUsername.equalsIgnoreCase(inputUsername)) {
    System.out.println("ログイン成功");
} else {
    System.out.println("ユーザー名が一致しません");
}

German.この例のように、大文字・小文字を無視して比較したい場面では equalsIgnoreCase() を使うのが適切です。

ただし、セキュリティ的にパスワード比較では大小文字を区別すべきなので、equals() を使いましょう。

Eingabevalidierung (Formularverarbeitung)

例えば、ドロップダウンやテキストボックスからの入力値のチェックにも、文字列比較が使われます。

String selectedOption = request.getParameter("plan");

if ("premium".equals(selectedOption)) {
    System.out.println("プレミアムプランを選択しました。");
} else {
    System.out.println("その他のプランです。");
}

このように、nullチェックを兼ねた安全な比較として "定数".equals(変数) の形式が実務でよく使われます。ユーザー入力は必ずしも値が存在するとは限らないため、NullPointerExceptionを防ぐための書き方です。

Mehrfachbedingte Verzweigungen (wie Switch verwenden)

複数の文字列候補を条件分岐で扱いたい場合は、equals()を連続して使うのが一般的です。

String cmd = args[0];

if ("start".equals(cmd)) {
    startApp();
} else if ("stop".equals(cmd)) {
    stopApp();
} else {
    System.out.println("コマンドが不正です");
}

Java 14以降では、文字列に対する switch 文も正式に使えるようになっています。

switch (cmd) {
    case "start":
        startApp();
        break;
    case "stop":
        stopApp();
        break;
    default:
        System.out.println("不明なコマンドです");
}

このように、文字列比較はロジックの分岐処理に直結するため、正確な理解が求められます。

Bugs bei Vergleichen mit null und deren Gegenmaßnahmen

よくある失敗例として、null値との比較でアプリがクラッシュするケースがあります。

String keyword = null;

if (keyword.equals("検索")) {
    // 例外発生：java.lang.NullPointerException
}

このようなケースでは、次のように書くことで安全に比較できます。

if ("検索".equals(keyword)) {
    System.out.println("検索実行");
}

または、より厳密なnullチェックを先に行う方法もあります。

if (keyword != null && keyword.equals("検索")) {
    System.out.println("検索実行");
}

null安全なコードは堅牢性を高めるうえで必須のスキルです。

5. Leistung und Optimierung

Verarbeitungskosten beim Vergleich von Zeichenketten

equals() や compareTo() は、一般に高速に動作するよう最適化されていますが、内部では1文字ずつ比較しているため、長い文字列や大量データを扱うときには影響が出ます。特に、ループの中で何度も同じ文字列と比較していると、意図しないパフォーマンス低下につながることがあります。

for (String item : items) {
    if (item.equals("keyword")) {
        // 比較回数が多い場合、注意
    }
}

Vergleichsbeschleunigung mit String.intern()

JavaのString.intern()メソッドを使うと、同じ内容の文字列をJVMの「文字列プール」に登録し、参照を共有することができます。これを利用すると、==での比較も可能になるため、性能上のメリットがある場合があります。

String a = new String("hello").intern();
String b = "hello";

System.out.println(a == b); // true

ただし、文字列プールを乱用するとヒープ領域が圧迫される可能性があるため、限られた用途での使用に留めるべきです。

Fallstricke von equalsIgnoreCase() und Alternativen

equalsIgnoreCase() は便利ですが、比較時に大文字・小文字を変換する処理が発生するため、通常のequals()よりも若干コストが高くなることがあります。性能がシビアな場面では、すでに大文字や小文字に統一した値で比較する方が高速です。

String input = userInput.toLowerCase();
if ("admin".equals(input)) {
    // 高速化された比較
}

このように事前に変換してからequals()を使うと、比較処理の効率を高められます。

Einsatz von StringBuilder / StringBuffer

大量の文字列連結が発生するようなケースでは、String を使っていると毎回新しいオブジェクトが生成され、メモリやCPUへの負荷が高くなります。比較処理が混在する場合も含め、連結や構築には StringBuilder を使い、比較には String のまま保持するのがベストプラクティスです。

StringBuilder sb = new StringBuilder();
sb.append("user_");
sb.append("123");

String result = sb.toString();

if (result.equals("user_123")) {
    // 比較処理
}

Design zur Beschleunigung durch Caching und Vorverarbeitung

同じ文字列との比較が何度も行われるような場合は、一度比較結果をキャッシュする、あるいはマップ（HashMapなど）を使って前処理することで、比較処理自体を減らすという手法も有効です。

Map<String, Runnable> commandMap = new HashMap<>();
commandMap.put("start", () -> startApp());
commandMap.put("stop", () -> stopApp());

Runnable action = commandMap.get(inputCommand);
if (action != null) {
    action.run();
}

このようにすれば、equals()による文字列比較は1回のMap検索に置き換わり、可読性とパフォーマンスの両方を向上させることができます。

6. Häufig gestellte Fragen (FAQ)

Q1. Was ist der Unterschied zwischen == und equals()?

A.
==は参照の比較（つまりメモリ上のアドレスの一致）を行います。一方でequals()は、文字列の中身（内容）を比較します。

String a = new String("abc");
String b = "abc";

System.out.println(a == b);        // false（参照が異なる）
System.out.println(a.equals(b));   // true（内容は同じ）

したがって、文字列の内容を比較したいときは必ずequals()を使用しましょう。

Q2. Warum führt die Verwendung von equals() zu einem Fehler, wenn null beteiligt ist?

A.
nullに対してメソッドを呼び出すと、NullPointerExceptionが発生するためです。

String input = null;
System.out.println(input.equals("test")); // 例外発生！

このエラーを防ぐには、次のように定数側から比較する書き方が安全です。

System.out.println("test".equals(input)); // false（安全）

Q3. Wie kann man vergleichen, ohne Groß‑ und Kleinschreibung zu beachten？

A.
Mit der Methode equalsIgnoreCase() können Sie Vergleiche durchführen, die Groß- und Kleinschreibung ignorieren.

String a = "Hello";
String b = "hello";

System.out.println(a.equalsIgnoreCase(b)); // true

Allerdings können bei Vollbreiten-Zeichen oder einigen speziellen Unicode-Zeichen die Ergebnisse unerwartet ausfallen, daher ist Vorsicht geboten.

Q4. Wie vergleicht man Strings nach Sortierreihenfolge?

A.
Um die lexikografische Vor- und Nachfolge von Strings zu prüfen, verwendet man compareTo().

String a = "apple";
String b = "banana";

System.out.println(a.compareTo(b)); // 負の値（"apple"は"banana"より前）

Bedeutung des Rückgabewerts:

• 0 → gleich
• Negativer Wert → Linke Seite ist vorne
• Positiver Wert → Linke Seite ist hinten

Es wird in Sortierungsprozessen usw. genutzt.

Q5. Welche Best Practices sollte man für String-Vergleiche im Gedächtnis behalten?

A.

• Für Inhaltsvergleiche immer equals() verwenden
• Null-Sicherheit beachten und die Form "Konstante".equals(variable) anstreben
• Für Ignorieren von Groß- und Kleinschreibung equalsIgnoreCase() oder vorherige toLowerCase() / toUpperCase()-Verarbeitung
• In Fällen mit vielen Vergleichen oder Notwendigkeit von Geschwindigkeit auch intern() oder Cache-Design in Betracht ziehen
• Lesbarkeit und Sicherheit im Gleichgewicht halten

7. Zusammenfassung

String-Vergleiche in Java erfordern die „richtige Unterscheidung“

In diesem Artikel haben wir die Grundlagen, die Praxis und die Performance-Aspekte von String-Vergleichen in Java umfassend erläutert. Da String in Java ein Referenztyp ist, kann eine falsche Vergleichsmethode zu unerwarteten Verhaltensweisen führen.

Insbesondere der Unterschied zwischen == und equals() ist ein Punkt, an dem Anfänger oft zuerst stolpern. Dies richtig zu verstehen und anzuwenden, ist unerlässlich, um sichere und zuverlässige Code zu schreiben.

Was man aus diesem Artikel gelernt hat (Checkliste)

• == vergleicht Referenzen (Speicheradressen)
• equals() vergleicht den Inhalt der Strings (sicherste Methode)
• Mit equalsIgnoreCase() kann man Groß- und Kleinschreibung ignorieren
• compareTo() ermöglicht lexikografische String-Vergleiche
• Mit der Reihenfolge "Konstante".equals(variable) kann man null-sicher vergleichen
• Für Performance-Optimierungen sind intern() oder Cache-Design wirksam

Wissen über String-Vergleiche, das auch in der Praxis nützlich ist

String-Vergleiche sind ein eng mit alltäglichen Entwicklungsaufgaben verbundenes Element, z. B. bei Login-Überprüfungen, Eingabevalidierungen, Datenbanksuchen oder Bedingungsverzweigungen. Mit diesem Wissen kann man Bugs vermeiden und Code realisieren, der wie beabsichtigt funktioniert.

Bei zukünftigen Verarbeitungen von Strings empfehle ich, den Inhalt dieses Artikels als Referenz zu nutzen und die passende Vergleichsmethode je nach Zweck auszuwählen.