Java Vergleichsoperatoren

Vergleichsoperatoren nehmen zwei Operanden und liefern einen boolean. Java besitzt sechs davon — gleich, ungleich und die vier relationalen Operatoren. Der Haken ist, dass == bei primitiven Typen etwas anderes macht als bei Objekten, was die häufigste Fehlerquelle für Anfänger ist.

Die sechs Operatoren

Jeder liefert einen boolean, den man in einem if-Test, einer Schleifenbedingung oder als Variablenwert verwenden kann:

int score = 85;
boolean passed = score >= 60;        // true
boolean perfect = score == 100;      // false
boolean failed = !(score >= 60);     // false

Die relationalen Operatoren (>, <, >=, <=) werden am häufigsten als if-Bedingungen und Schleifenwächter verwendet:

int temperature = 30;

if (temperature > 25) {
  System.out.println("warm");        // printed
} else if (temperature < 10) {
  System.out.println("cold");
}

for (int i = 0; i < 3; i++) {        // i < 3 is the loop guard
  System.out.println(i);             // 0 1 2
}

== bei primitiven Typen

Bei primitiven Typen vergleicht == den Wert:

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

double x = 0.1 + 0.2;
double y = 0.3;
System.out.println(x == y);    // false — IEEE 754 rounding

Der Gleitkommafall ist eine Erinnerung: double-Werte nicht auf exakte Gleichheit vergleichen. Prüfe stattdessen, ob sie innerhalb einer kleinen Toleranz liegen:

System.out.println(Math.abs(x - y) < 1e-9);   // true

== bei Objekten — Identität, nicht Gleichheit

Bei Referenztypen vergleicht == Referenzen — ob die beiden Variablen auf dasselbe Objekt im Speicher zeigen. Zwei unterschiedliche Objekte mit identischem Inhalt sind nicht ==:

String s1 = new String("hello");
String s2 = new String("hello");

System.out.println(s1 == s2);          // false — different objects
System.out.println(s1.equals(s2));     // true  — same contents

Die Faustregel lautet: Für Objekte immer .equals() verwenden, um Inhalte zu vergleichen.

if (input.equals("quit")) { ... }      // correct
// if (input == "quit") { ... }        // works by coincidence, don't rely on it

Die Form == "quit" gibt manchmal true zurück, weil Java String-Literale dedupliziert — dasselbe Literal wird zum selben Objekt kompiliert. Das ist aber ein Implementierungsdetail, keine Garantie.

Objects.equals — null-sicher

Wenn eine Seite null sein könnte, wirft obj.equals(other) eine NullPointerException. Verwende stattdessen Objects.equals — es behandelt null auf beiden Seiten:

import java.util.Objects;

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

System.out.println(Objects.equals(a, b));   // false (no NPE)
System.out.println(Objects.equals(a, null)); // true

Wrapper-Objekte vergleichen

Wrapper-Typen (Integer, Long usw.) folgen der Objektregel — == vergleicht Referenzen, nicht Werte:

Integer x = 200;
Integer y = 200;
System.out.println(x == y);         // false (usually)
System.out.println(x.equals(y));    // true

(Werte von -128 bis 127 werden gecacht, sodass Integer x = 100; Integer y = 100; x == y zufällig true ergibt — aber das ist eine JVM-Eigenheit, keine Sprachregel. Darauf sollte man sich nicht verlassen.)

Für Sortierung vergleichen — .compareTo

<, >, <=, >= funktionieren nur bei primitiven Typen. Um Objekte für eine Sortierung zu vergleichen, verwende die Methode Comparable.compareTo (gibt negativ, null oder positiv zurück):

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

System.out.println(a.compareTo(b));   // negative — "apple" < "banana"
System.out.println(a.compareTo(a));   // 0
System.out.println(b.compareTo(a));   // positive

Integer, Long, String, LocalDate und die meisten „natürlichen" Typen implementieren Comparable. Benutzerdefinierte Sortierung verwendet Comparator — behandelt in Comparable und Comparator.

Eine Demonstration

Was kommt als Nächstes

Java Logische Operatoren — boolesche Ausdrücke mit &&, || und ! kombinieren.

Übungen