Java-Grundlagen: Relationale Operatoren in Java

In Java sind 6 relationale Operatoren implementiert. Alle 6 relationalen Operatoren erwarten numerische Operanden. Dabei ist es möglich integrale und Gleitkomma-Datentypen als Operanden zu verwenden. Die unterschiedlichen Datentypen können auch in einem relationalen Ausdruck zusammen verwendet werden.

Für die beiden relationalen Operatoren Gleich und Ungleich können neben den numerischen Operanden auch Referenztypen verwendet werden. Sie vergleichen die in den Variablen gespeicherten Referenzen und nicht die Objekte selbst.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

In Ausdrücken können Java-Operatoren mehrere Argumente zugewiesen werden. Die mögliche Anzahl ist durch die Stelligkeit des Operators vorgegeben, diese gibt an wie viele Argumente er benötigt. Die relationalen Operatoren: Gleich, Ungleich, Kleiner als, Kleiner gleich, Größer als und Größer gleich benötigen 2 Operanden.

Mit den 6 relationalen Operatoren können in Java Ausdrücke miteinander verglichen werden. Als Rückgabewert wird entweder true oder false zurückgegeben.

Die folgende Tabelle stellt die relationalen Operatoren von Java einzeln vor:

Operator Bezeichnung Beispiel Beschreibung
== Gleich a == b Es wird a mit b verglichen. Ist a gleich b wird true zurückgegeben, andernfalls false. Wenn a und b Referenztypen sind, wird verglichen ob beide Variablen auf das gleiche Objekt referenzieren. Falls ja, wird true zurückgegeben.
!= Ungleich a != b Es wird a mit b verglichen. Ist a ungleich b wird true zurückgegeben, andernfalls false. Wenn a und b Referenztypen sind, wird verglichen ob beide Variablen auf verschiedene Objekte referenzieren. Falls ja, wird true zurückgegeben.
< Kleiner als a < b Es wird a mit b verglichen. Ist a kleiner als b wird true zurückgegeben, andernfalls false.
<= Kleiner gleich a <= b Es wird a mit b verglichen. Ist a kleiner als oder gleich b wird true zurückgegeben, andernfalls false.
> Größer als a > b Es wird a mit b verglichen. Ist a größer als b wird true zurückgegeben, andernfalls false.
>= Größer gleich a >= b Es wird a mit b verglichen. Ist a größer als oder gleich b wird true zurückgegeben, andernfalls false.

In dem folgenden Beispielprogramm werden die relationalen Operatoren verwendet.

In dem ersten Teil des Quelltextes werden die relationalen Operatoren mit numerischen Ausdrücken verwendet. Es wird für jeden relationalen Operator ein Beispiel für ganzzahlige Operanden und eines für Gleitkomma-Operanden angegeben.

Im zweiten Teil des Quelltextes, ab Zeile 53, werden die relationalen Operatoren Gleich und Ungleich auf Referenztypen angewendet. Besonders zu beachten ist die Sonderbehandlung von String-Objekten.

Werden String-Objekte als Literale zur Kompilier-Zeit angelegt, werden sie von dem Compiler als konstant erkannt. String-Literale werden mit Hilfe der Methode String.intern angelegt. Diese Methode verwaltet einen String-Puffer, in dem jede Zeichenkette nur einmal enthalten ist.

Wird eine bereits existierende Zeichenkette ein zweites Mal einem String-Objekt als Literal zugewiesen, dann findet die Methode String.intern das bereits existierende String-Objekt und liefert einen Zeiger auf dieses Objekt zurück.

Dadurch sind literal erzeugte String-Objekte, die die gleiche Zeichenkette enthalten, nicht nur inhaltlich identisch, sondern auch das gleiche Objekt im Speicher. Beide String-Referenzvariablen enthalten dann die gleiche Referenzadresse als Referenz zum Objekt.

Beispiel relationale Operatoren in Java.

/*
* Beispielanwendung relationale Operatoren in Java.
*/

public class RelationaleOperatoren{
 public static void main(String[] args) {
 
  byte  aB = 9,    bB = 4;
  float aF = 9.9F, bF = 4.5F;
  boolean ergebnisB, ergebnisF, ergebnisS;

  System.out.println("\naB = " + aB + "     aF = " + aF);
  System.out.println("bB = " + bB + "     bF = " + bF);

  ergebnisB = aB < bB;
  ergebnisF = aF < bF;

  System.out.println("\nKleiner als (ganzzahlig):   aB < bB = " + ergebnisB);
  System.out.println("Kleiner als (Gleitkommazahl): aF < bF = " + ergebnisF);

  ergebnisB = aB <= bB;
  ergebnisF = aF <= bF;

  System.out.println("\nKleiner gleich (ganzz.): aB <= bB = " + ergebnisB);
  System.out.println("Kleiner gleich (Gleitk.):  aF <= bF = " + ergebnisF);

  ergebnisB = aB > bB;
  ergebnisF = aF > bF;

  System.out.println("\nGroesser als (ganzz.): aB > bB = " + ergebnisB);
  System.out.println("Groesser als (Gleitk.):  aF > bF = " + ergebnisF);

  ergebnisB = aB >= bB;
  ergebnisF = aF >= bF;

  System.out.println("\nGroesser gleich (ganzz.): aB >= bB = " + ergebnisB);
  System.out.println("Groesser gleich (Gleitk.):  aF >= bF = " + ergebnisF);

  ergebnisB = aB == bB;
  ergebnisF = aF == bF;

  System.out.println("\nGleich (ganzz.): aB == bB = " + ergebnisB);
  System.out.println("Gleich (Gleitk.):  aF == bF = " + ergebnisF);

  ergebnisB = aB != bB;
  ergebnisF = aF != bF;

  System.out.println("\nUngleich (ganzz.): aB != bB = " + ergebnisB);
  System.out.println("Ungleich (Gleitk.):  aF != bF = " + ergebnisF);



  Object aObj = new Object(), bObj = new Object();
  System.out.println("\n\naObj = " + aObj + "\nbObj = " + bObj);

  ergebnisS = aObj == bObj;
  System.out.println("\nGleich (Referenztyp): aObj == bObj = " + ergebnisS);

  ergebnisS = aObj != bObj;
  System.out.println("Ungleich (Referenztyp): aObj != bObj = " + ergebnisS);

  //ergebnisS = aObj < bObj ; // Compiler-Fehler: bad operand types


  Object aS = "Hallo PLHQ - Literal", bS = "Hallo PLHQ - Literal";
  System.out.println("\n\naS = " + aS + "     bS = " + bS);

  ergebnisS = aS == bS;
  System.out.println("\nGleich (Referenztyp):       aS == bS = " + ergebnisS);

  ergebnisS = aS!= bS;
  System.out.println("Ungleich (Referenztyp):     aS != bS = " + ergebnisS);


  aS = new String ("Hallo PLHQ - new Operator");
  bS = new String ("Hallo PLHQ - new Operator");
  System.out.println("\n\naS = " + aS + "     bS = " + bS);

  ergebnisS = aS == bS;
  System.out.println("\nGleich (Referenztyp):       aS == bS = " + ergebnisS);

  ergebnisS = aS!= bS;
  System.out.println("Ungleich (Referenztyp):     aS != bS = " + ergebnisS);

 }
}

Die meisten Ausdrücke im oberen Quelltext sind selbsterklärend. Es werden immer die Variablen aB, aF, bB und bF als Operanden mit verschiedenen relationalen Operatoren benutzt.

Für die Referenztypen werden die Variablen aObj, bObj, aS und bS als Operanden verwendet und mit den relationalen Operatoren Gleich und Ungleich benutzt.

Die zugehörige Textausgabe ist in der unten abgebildeten Kommandozeilenausgabe dargestellt.

Java relationale Operatoren in Ausdrücken

Java relationale Operatoren – Ausgabe der Beispielanwendung


Comments 3

  1. Pingback: Operatoren, Ausdrücke und Anweisungen in Java -

  2. Pingback: Java-Grundlagen: Besondere Operatoren in Java

  3. Pingback: Java-Grundlagen: Ausdrücke, die kleinsten ausführbaren Einheiten in Java

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.