Vergleiche in Java 

Einführung

Der Operator »<«

Ein Ausdruck mit »<« als Hauptoperator hat den Wert »true« genau dann ergibt, wenn der Wert des linken Operanden kleiner  als der Wert des rechten Operanden ist.

Der Ausdruck »1 < 2« hat daher beispielsweisen den Wert »true«.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 1 < 2 ); }}

Protokoll

true

Der Operator »>«

Ein Ausdruck mit »<« als Hauptoperator hat den Wert »true« genau dann ergibt, wenn der Wert des linken Operanden größer  als der Wert des rechten Operanden ist.

Der Ausdruck »2 > 1« hat daher beispielsweisen den Wert »true«.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 2 > 1 ); }}

Vereinfachte Syntax

Syntaxdiagramm

Ausdruck
    .----------.     .-.    .----------.
--->| Ausdruck |--->( < )-->| Ausdruck |--->
    '----------'     '-'    '----------'

Syntaxdiagramm

Ausdruck
    .----------.     .-.    .----------.
--->| Ausdruck |--->( > )-->| Ausdruck |--->
    '----------'     '-'    '----------'

Mathematische Schreibweise

Die mathematische Schreibweise dieser Operatoren ist ebenfalls ‹<› bzw ‹>›.

Aussprache

Der Operator »<« wird „kleiner“, „kleiner als“ oder „ist kleiner als“ gesprochen.

Man kann »2<x« aber auch umgekehrt als „x ist größer als 2.“ aussprechen.

Der Operator »>« wird „größer“, „größer als“ oder „ist größer als“ gesprochen.

Priorität

Die folgende Tabelle gibt die Assoziativität und Priorität der bisher behandelten Operatoren wieder.

Eigenschaften

        S P A    (S = Stelligkeit ("Aritaet"), P = Position, A = Assoziativitaet)
()      1 Z      Eingeklammerter Ausdruck
+  -    1 P      Unaere vorangestellte Operatoren (Vorzeichen)
*  /    2 I L    "Punktrechnung":  Multiplikation, Division
+  -    2 I L    "Strichrechnung": Addition, Subtraktion
<  >    2 I L    Vergleiche
== !=   2 I L    Gleichheitspruefung und Ungleichheitspruefung
=       2 I R    Zuweisung

Die Priorität der Operatoren »<« und »>« ist schwächer als die der Operatoren zur arithmetischen Berechnung eines Wertes aber stärker als die der Gleichheitsprüfungen und der Zuweisungen.

Wir illustrieren die Priorität dieser Operatoren durch Auflistung einiger Ausdrücke gleicher Bedeutung.

Priorität

Ausdruck               Ausdruck mit gleicher Bedeutung
false == a < 2         false ==( a < 2 )
x = a < 2              x =( a < 2 )
2 + 3 < a * -4         ( 2 + 3 )<( a * -4 )

Ausdrücke ⊚

Die Definition eines Ausdrucks wird um Ausdrücke mit dem neu vorgestellten Operator erweitert.

Syntaxdiagramm

Ausdruck
                 .----------.
---.------------>| Literal  |------------------------------.---->
   |             '----------'                              |
   |             .----------.                              |
   '------------>| Name     |------------------------------'
   |             '----------'                              |
   |     .-.     .----------.     .-.                      |
   '--->( ( )--->| Ausdruck |--->( ) )---------------------'
   |     '-'     '----------'     '-'                      |
   |             .----------.                              |
   '------------>| Aufruf   |------------------------------'
   |             '----------'                              |
   |     .-.     .----------.                              |
   '--->( - )--->| Ausdruck |------------------------------'
   |     '-'     '----------'                              |
   |     .-.     .----------.                              |
   '--->( + )--->| Ausdruck |------------------------------'
   |     '-'     '----------'                              |
   |             .----------.     .-.      .----------.    |
   '------------>| Ausdruck |--->( / )---->| Ausdruck |----'
   |             '----------'     '-'      '----------'    |
   |             .----------.     .-.      .----------.    |
   '------------>| Ausdruck |--->( + )---->| Ausdruck |----'
   |             '----------'     '-'      '----------'    |
   |             .----------.     .-.      .----------.    |
   '------------>| Ausdruck |--->( - )---->| Ausdruck |----'
   |             '----------'     '-'      '----------'    |
   |             .----------.     .-.      .----------.    |
   '------------>| Ausdruck |--->( * )---->| Ausdruck |----'
   |             '----------'     '-'      '----------'    |
   |             .----------.     .-.      .----------.    |
   '------------>| Ausdruck |--->( < )---->| Ausdruck |----'
   |             '----------'     '-'      '----------'    |
   |             .----------.     .-.      .----------.    |
   '------------>| Ausdruck |--->( > )---->| Ausdruck |----'
   |             '----------'     '-'      '----------'    |
   |             .----------.     .--.     .----------.    |
   '------------>| Ausdruck |--->( == )--->| Ausdruck |----'
   |             '----------'     '--'     '----------'    |
   |             .----------.     .--.     .----------.    |
   '------------>| Ausdruck |--->( != )--->| Ausdruck |----'
   |             '----------'     '--'     '----------'    |
   |             .----------.     .-.      .----------.    |
   '------------>| Ausdruck |--->( = )---->| Ausdruck |----'
                 '----------'     '-'      '----------'

Typanforderungen (vereinfacht)

Bei den Operanden dieser Operatoren muß es sich um numerische Typen  handeln. Bei einer Kombination von »int« und »double« wird der int-Wert vor dem Vergleich nach »double« gewandelt.

Signaturen möglicher Vergleiche

int    < int
int    < double  (als double < double)
double < int     (als double < double)
double < double  (als double < double)

Für den Operator »>« sind die entsprechenden Signaturen möglich.

Typ des Ausdrucks

Der Typ eines mit diesem Operator gebildeten Ausdrucks zum Vergleich ist immer »boolean«.

Semantik (Wert)

Bei der Auswertung dieser Operatoren werden zunächst beide Operanden ausgewertet.

Der Wert eines Vergleiches mit »<« ist »true« genau dann wenn der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist.

Der Wert eines Vergleiches mit »>« ist »true« genau dann wenn der Wert des linken Operanden größer als der Wert des rechten Operanden ist.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 1 < 2 ); 
    java.lang.System.out.println( 0.0 < 0.00 ); 
    java.lang.System.out.println( 1.9999999999999999 < 2.0 ); }}

java.lang.System.out

true
false
false

Beispiele ⃗

Der Wert eines Aufrufs von »java.lang.Math.random()« darf nicht negativ sein.

Das folgende Programm setzt den Wert der final-Variablen »zuKlein« auf »true«, falls doch einmal gegen diese Regel verstoßen werden sollte. Wir erwarten aber keinen Verstoß gegen diese Regel und somit die Ausgabe des Wertes »false«.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    final double zufallszahl = java.lang.Math.random();
    final boolean zuKlein = zufallszahl < 0;
    java.lang.System.out.println( zuKlein ); }}

Protokoll

false

Das folgende Programm erledigt die Prüfung mit einer Methode.

Main.java

public final class Main
{
  public static boolean zuKlein( final double x )
  { return x < 0; }
  public static void main( final java.lang.String[] args )
  { 
    final double zufallszahl = java.lang.Math.random();
    java.lang.System.out.println( zuKlein( zufallszahl )); }}

Protokoll

false

Der Wert eines Aufrufs von »java.lang.Math.random()« darf nicht 1 oder mehr sein.

Das folgende Programm setzt den Wert der final-Variablen »zuGross« auf »true«, falls doch einmal gegen diese Regel verstoßen werden sollte. Wir erwarten aber keinen Verstoß gegen diese Regel und somit die Ausgabe des Wertes »false«.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    final double zufallszahl = java.lang.Math.random();
    final boolean zuGross = zufallszahl < 1 == false;
    java.lang.System.out.println( zuGross ); }}

Protokoll

false

Das folgende Programm setzt den Wert der final-Variablen »schlecht« auf »true«, falls sich eine Zufallszahl außerhalb des erlaubten Bereich befindet. Wir erwarten also »false«.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    final double zufallszahl = java.lang.Math.random();
    final boolean zuKlein = zufallszahl < 0;
    final boolean zuGross = zufallszahl < 1 == false;
    final boolean schlecht = java.lang.Boolean.logicalOr( zuKlein, zuGross );
    java.lang.System.out.println( schlecht ); }}

Protokoll

false

Man beachte, wie die sprechenden Variablennamen das Verständnis des Programms erleichtern.

Übungsfragen

?   Übungsfrage

Welche Ausgabe erzeugt das folgende Programm?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 2 < 3 ); }}

?   Übungsfrage 1

Welche Ausgabe erzeugt das folgende Programm?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 3 < 3 ); }}

?   Übungsfrage 2

Welche Ausgabe erzeugt das folgende Programm?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 2 + 1 < 3 ); }}

?   Übungsfrage 3

Welche Ausgabe erzeugt das folgende Programm?

Main.java

public final class Main
{ 
  public static boolean f( final int i ){ return i < 4; }
  public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( f( 4 ));
    java.lang.System.out.println( f( 5 )); }}

Übungsaufgaben

/   Vergleichsmethode

Schreiben Sie eine möglichst kurze Deklaration einer Methode »isLess(int,int)«, die genau dann »true« ergibt, wenn der Wert des ersten Arguments ihres Aufrufs kleiner als der Wert des zweiten Arguments ihres Aufrufs ist. (Die Länge einer Methodendeklaration wird bei dieser Aufgabe durch die Anzahl der lexikalischen Einheiten jener Methodendeklaration bestimmt.)

Wenn die Methode richtig geschrieben wurde, gibt das Programm immer nur »true« aus.

Main.java

public final class Main
{ 
  public static boolean isLess( final int i, final int j ){ … } 
  public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( isLess( 0, 0 )== false  );
    java.lang.System.out.println( isLess( 0, 1 )== true  );
    java.lang.System.out.println( isLess( 1, 0 )== false );
    java.lang.System.out.println( isLess( 1, 1 )== false ); }}

transcript

true
true
true
true

/   Vergleichsmethode 1

Schreiben Sie eine Methode »isGreater(int,int)«, die genau dann »true« ergibt, wenn der Wert des ersten Arguments ihres Aufrufs größer als der Wert des zweiten Arguments ihres Aufrufs ist.

Wenn die Methode richtig geschrieben wurde, gibt das Programm immer nur »true« aus.

Main.java

public final class Main
{ 
  …
  public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( isGreater( 0, 0 )== false );
    java.lang.System.out.println( isGreater( 0, 1 )== false );
    java.lang.System.out.println( isGreater( 1, 0 )== true  );
    java.lang.System.out.println( isGreater( 1, 1 )== false ); }}

transcript

true
true
true
true