Skip to main content

So lassen sich Java Strings vergleichen

Du willst in Java Strings vergleichen – Kein Problem.

So geht’s.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = new String ("Apfel");
		String frucht2 = new String ("Apfel");
		
		if (frucht1 =="Apfel"){
			System.out.println("Es ist ein Apfel");
		}
		else {
			System.out.println("Es ist eine Birne");
		}
	}
}

Na, welche Bildschirmausgabe wird hier zurückgeworfen?
Ja – Birne.
Und das obwohl ganz klar die gleichen Textwerte geprüft werden.

Aber es wird noch verrückter.
Probiere den Code aus.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = new String ("Apfel");
		String frucht2 = new String ("Apfel");
		
		if (frucht1 ==frucht2){
			System.out.println("Zwei Äpfel");
		}
		else {
			System.out.println("Früchte sind unterschiedlich");
		}
	}
}

Selbst hier bekommst du die zweite, also die falsche, Meldung zurück.

Lass uns noch einen Code probieren.
Versprochen – diese Irreführung hört gleich auf. 🙂

Es werden jetzt beide String-Objekte nicht über den Konstruktor angelegt.
Und es erfolgt eine einfache Zuweisung der Textwerte.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = "Apfel";
		String frucht2 = "Apfel";
		
		//Prüfung 1
		if (frucht1=="Apfel"){
			System.out.println("Es ist ein Apfel");//Diese Ausgabe erscheint
		}
		else {
			System.out.println("Es ist eine Birne");
		}
		
		//Prüfung 2
		if (frucht1 ==frucht2){
			System.out.println("Zwei Äpfel");//Diese Ausgabe erscheint
		}
		else {
			System.out.println("Früchte sind unterschiedlich");
		}
	}
}

Jetzt bekommst du die richtigen Konsolenausgaben zurück.

Was ist passiert?
Ich plädiere auf reine Java-Willkür. 🙂

Nein es ist nur Spaß und dahinter steckt wirklich ein nützliches Konzept.

Wenn du Java Strings vergleichst, ist das wirklich so – als würdest du Äpfel und Birnen vergleichen.

Denn Strings sind echte Java Objekte.

Und die Variablen frucht1 und frucht2 sind keine Objekte.
Es sind lediglich Referenzvariablen, welche eine Speicheradresse beinhalten.

Und String Objekte, welche du über einen Konstruktor erzeugst – landen auf dem Heap.
Das ist das Speichersystem für alle Java Objekte.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = new String ("Apfel");//wird auf dem Heap verwaltet
		String frucht2 = new String ("Apfel");//wird auf dem Heap verwaltet
		}
	}

Und so kannst du dir dann deine Objekte im Heap-Speicher vorstellen.

Java-Strings-Apfel

Und die Referenzvariablen würden dann lediglich als Wert die Speicheradresse tragen.
Java Strings Referenzen Adressen

Und wenn du jetzt frucht1 mit frucht2 vergleichst.
Dann vergleichst du nur ob die Adresse des ersten Objektes mit der Adresse des zweiten Objektes übereinstimmt.
Java Strings Verweise if

Und da beide Adressen nicht übereinstimmen, würde dieser Code nicht funktionieren.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = new String("Apfel");// wird auf dem Heap verwaltet
		String frucht2 = new String("Apfel");// wird auf dem Heap verwaltet

		// Intern wird geprüft ob Speicherplatz 001 == 002 ist
		if (frucht1 == frucht2) {
			System.out.println("Es ist ein Apfel");
		} else {
			System.out.println("Es ist eine Birne");
		}
	}
}

Anders ist es mit den String-Objekten, welche ohne Konstruktor erstellt werden.

Diese landen nämlich nicht in diesem Speichersystem.
Sie landen in einem string-optimierten Speichersystem.
Dem String Pool.

String Pool – was ist das?
Java ist schlau und sagt sich:

„Wieso soll ich zweimal das selbe Objekt erschaffen und dieses mit kostbaren Speicher ausstatten.“

„Ist es nicht viel besser ein Objekt zu erschaffen und sobald ich bemerke, dass noch ein Objekt mit selben Textwert entsteht – verweise ich nur noch darauf.“

„Dann habe ich zwar zwei Verweise, aber nur ein Objekt.“

Und genau das passiert auch, wenn du Strings anlegst ohne den Konstruktor aufzurufen.
Diese landen im Pool.

Java Strings Pool Adressen

Und dieser Pool ist ein Unterspeichersystem des Heapspeicher.
Der Pool hat somit auch Adressen.

Aber alle gleichen String-Objekte, welche in den Pool kommen – landen bei der selben Adresse.
Es verweisen dann zwei Variablen auf ein- und dasselbe Objekt und somit auf dieselbe Adresse.

Java Strings Pool gleiche Adressen

Wichtig ist:
Java macht das selbstständig für dich.
Du legst ein String-Objekt an.
Java prüft, ob es schon genau den selben Text im Pool gibt.
Falls ja – verweist Java die Referenzvariable an die entsprechende Adresse im Pool.

Ein Birnen-String würde dann in Speicher 2 landen.
Und alle Referenzvariablen mit dem Textwert „Birne“ würden auf Speicherplatz 2 zeigen.
Ein Pfirsich in drei. usw.

Also Referenzvariablen mit gleichen Textwert zeigen auf ein- und dasselbe Objekt im Pool.
Und somit wäre Birne gleich Birne und Apfel gleich Apfel.

Dann würde sich eine Prüfung der Werte als richtig einstellen.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = "Apfel";// wird im Pool verwaltet
		String frucht2 = "Apfel";// wird im Pool verwaltet

		// Intern wird geprüft ob Speicherplatz Pool-001 == Pool-001 ist
		if (frucht1 == frucht2) {
			System.out.println("Es ist ein Apfel");
		} else {
			System.out.println("Es ist eine Birne");
		}
	}
}

Ja- so könnte man Strings vergleichen.

Du merkst es – die Betonung liegt auf könnte.
Denn es ist nur ein Vergleich auf Speicheradressen.

Viel besser wäre es doch den String Buchstaben für Buchstaben zu durchlaufen und zu prüfen.

Und das mit eine Schleife.

Keine Angst die gibt es schon.
Die Methode heißt equals.

Und jedes Objekt, also auch die Strings können diese Methode nutzen.
Dazu einfach:

  1. Den Namen der Referenzvariablen schreiben „frucht1“
  2. Den Punkt setzen, um die Punktnotation am Objekt einzuleiten
  3. Und dann die Methode am Objekt aufrufen.

Diese Methode verlangt dann noch einen Parameter.
Also übergibst du den Vergleichswert.
Und Fertig.

Und so könnte dies dann aussehen:

  • frucht1.equals("Apfel");– vergleicht das Objekt für Frucht1 mit dem Textwert Apfel
  • frucht1.equals("Birne");-vergleicht den Textwert aus Frucht1 mit dem Textwert Birne
  • frucht2.equals("Pfirsich");-vergleicht den Textwert aus Frucht2 mit dem Textwert Pfirsich
  • frucht1.equals(frucht2);-vergleicht die Textwerte für Frucht1 und Frucht2 miteinander

In einer if else Abfrage könnte dies dann so aussehen:
Es wird geprüft, ob Frucht1 ein Apfel ist.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = "Apfel";// wird im Pool verwaltet
		String frucht2 = "Apfel";// wird im Pool verwaltet

		// Wird geprüft ob Frucht 1 ein Apfel ist
		if (frucht1.equals("Apfel")) {
			System.out.println("Es ist ein Apfel");
		} else {
			System.out.println("Es ist eine Birne");
		}
	}
}

Oder so:
Jetzt wird geprüft, ob Frucht1 eine Birne ist.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = "Apfel";// wird im Pool verwaltet
		String frucht2 = "Apfel";// wird im Pool verwaltet

		// Wird geprüft ob Frucht 1 ein Birne ist
		if (frucht1.equals("Birne")) {
			System.out.println("Es ist eine Birne");
		} else {
			System.out.println("Es ist ein Apfel");
		}
	}
}

Probiere jetzt einmal die Werte in deinem Code zu ändern.
Ändere den Wert für Frucht1 in Birne
Ändere die Abfrage und lass Frucht2 mit „Birne“ vergleichen.
Probiere etwas rum und werde sicherer im Umgang.

Und das letzte Beispiel.
In diesem Beispielcode wird geprüft, ob Frucht 1 und Frucht2 das selbe sind.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = "Apfel";// wird im Pool verwaltet
		String frucht2 = "Apfel";// wird im Pool verwaltet

		// Wird geprüft ob Frucht1 und Frucht2 gleich sind
		if (frucht1.equals(frucht2)) {
			System.out.println("Zwei gleiche Früchte");
		} else {
			System.out.println("unterschiedliche Früchte");
		}
	}
}

Auch hier kannst du ruhig etwas mit dem Code spielen.

Bei der equals-Vergleichsmethode spielt es keine Rolle, wo deine Strings liegen

Du kannst jetzt alle Strings vergleichen.
Es spielt also keine Rolle, ob diese mit Konstruktor oder ohne Konstruktor angelegt wurden.


public class StringVergleichen {

	public static void main(String[] args) {
		String frucht1 = "Apfel";// wird im Pool verwaltet
		String frucht3 = new String ("Birne");//wird auf dem Heap verwaltet

		// Wird geprüft ob Frucht1 und Frucht3 gleich sind
		if (frucht1.equals(frucht3)) {
			System.out.println("Zwei gleiche Früchte");
		} else {
			System.out.println("unterschiedliche Früchte");
		}
	}
}

Zusammenfassung:

  • Strings kannst du entweder über einen Konstruktoraufruf anlegen oder ohne.
  • In Java lassen sich Strings, welche ohne Konstruktor angelegt wurden mit dem Gleichheitsoperator vergleichen.
  • Dennoch werden auch hier nur Speicheradressen verglichen.
    Prinzipiell solltest du alle Java Strings mit der equals Methode vergleichen.

Ähnliche Beiträge

Du bekommst was du vereinbarst – Die Rückgabewerte von Java Methoden

Java Methoden Rückgabetypen

Was du vereinbarst, das bekommst du zurück. Ach wäre es schön, wenn alles im Leben so funktionieren würde. Aber zum Glück funktioniert dieses Prinzip bei deinen Java Methoden. Denn du kannst den Rückgabetypen im Methodenkopf vereinbaren. Doch bevor ich dir zeige, wie du den Rückgabetypen anlegen kannst…. Lass mich dir zeigen, wofür du den Kram […]

10 ganz nützlichen Feature der Klasse Java Math

In diesem Beitrag geht es um eine spezielle Java Klasse. Die Klasse nennt sich Java Math. Diese ist in der Standardbibliothek von Java enthalten. Warum solltest du diese Klasse kennen? Die Math Klasse bietet dir einen Menge Methoden an, welche zur Berechnung von mathematischen Gleichungen ganz hilfreich sind. Aber auch für Nichtmathematiker ist etwas dabei. […]

So kannst du gelöschte Java Projekte oder Dateien in Eclipse wieder herstellen

Wahrscheinlich passiert es jedem einmal, dass man versehentlich Dateien löscht. Und dann? Die Wut ist riesig, weil man ja alles nochmal schreiben muss. In Eclipse hast du die Möglichkeit sämtliche Dateien wieder herzustellen. In diesem Beitrag möchte ich dir demonstrieren, wie du gelöschte Java Klassen, Dateien, Projekte oder Packages wieder herstellen kannst.

So kannst du Java Konstruktoren anlegen und überladen

Java Konstruktoren

Der Name sagt es schon. Java Konstruktoren konstruieren oder bauen Java Objekte. Und diese Objekte baut der Konstruktor auf Vorlage der entsprechenden Java Klasse. In diesem Beitrag zeige ich dir natürlich verschiedene Ansätze wie du den Konstruktor einsetzt. Ich zeige dir dies Schritt für Schritt. Dabei zeige ich dir auch verschiedene Dinge, welche nicht funktionieren. […]

Das Instanzieren von Java Klassen verhindern

Java Objekte Instanzieren verhindern

Die Instanzierung von Java Klassen verhindern. Was heißt das? Instanzen sind die Objekte einer Java Klasse. Und Instanzieren oder Instanzierung heißt nichts anderes, als Objekterstellung. Aber was soll das? Oder mal anders gefragt: Wieso sollte man verhindern, dass eine Java Klasse – Objekte erstellen kann? Schließlich sind doch Objekte der Sinn und Zweck jeder objektorientierten […]

Java Übung 16 – Bestimme den größten gemeinsamen Teiler

Java Übung Teiler

In dieser Java Übung möchte ich, dass du den größten gemeinsamen Teiler zwei Zahlen ermittelst. Ich möchte, dass du das Ganze mit einer while-Schleife umsetzt. Und wie? Du legst eine neue Klasse „GGT“ (größter gemeinsamer Teiler) an. In diese Klasse implementierst du eine Klassenmethode „berechneGGT“. Diese erwartet zwei Argumente vom Datentyp Integer.

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]

Java Methoden mit variabler Argumentenanzahl – VarArgs

Java Methoden mit variabler Argumentenanzahl VarArgs

Du kennst das noch. Kopfrechnen und zwar auf Zeit. So etwas ist das Standardprogramm in den Schulklassen 1 bis 5. Irgendwann, in Klasse 6 oder 7, kommt der Taschenrechner ins Spiel und Kopfrechnen ist aus dem Schulalltag gestrichen. Schade eigentlich. Dabei kann man diese Disziplin auch wunderbar in kleinen Spielen unterbringen. Ich erinnere mich noch: […]

So kannst du ein Java Programm starten und Argumente übergeben

Um ein Java Programm starten zu können, benötigst du immer die main-Methode. Das Programm startet immer genau an dieser Stelle. Alle lokalen Variablen, welche du in der Main Methode anlegst, kannst du dann im Programm nutzen. Auch alle Methoden, welche du innerhalb des Methodenrumpfes der main-Methode aufrust, werden ausgeführt. Was ist aber vor der main-Methode. […]

Java lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

So verwendest du die Java Codeblöcke zur Automatisierung

Java Codeblöcke

In diesem Beitrag geht es um den Einsatz von Java Codeblöcken oder Initialisierungsblöcken. Viele Wege führen nach Rom. Oder Alle Wege führen nach Rom. Heißt es in einem alten Sprichwort. Und so ähnlich ist es bei der Java Programmierung. In diesem Beitrag möchte ich dir einen weiteren Weg vorstellen, wie du Variablen eines Java Objektes […]