"gleich gleich" oder equals

[usija]

hallo,

wann muss ich bei objekten eigentlich den == operator benutzen bzw. wann equals.

wenn ich ein objekt hab das null ist und ich prüfen möchte muss ich == nehmen (das hab ich durch trial & error festgestellt), da mir equals(null) eine Null-Pointer Exception liefert

was ich so gelesen hab, prüft == ob es sich bei den zu vergleichenden objekten um die selbe referenz handelt. sprich ob die objekte wirklich identisch sind(speicheradresse).

gibts es daher nur 1 null objekt ? wenn ich ein objekt null setze und es auf null prüfe(mit ==), dann ergibt das ja eine wahre aussage.

aus der vorlesung hab ich "aufgeschnappt"(nicht wirklich verstanden) das java feststellt wenn mehrere objekte erzeugt werden sollen, die gleich sind und dann das objekt nur einmal erstellt und einfach alle variablen auf das selbe objekt zeigen lässt.

seh ich das richtig?

 

[SlaterB]

> wenn ich ein objekt null setze und es auf null prüfe(mit ==), dann ergibt das ja eine wahre aussage.

jo

> gibts es daher nur 1 null objekt ?

das ist mehr eine philosophische Frage und wegen obigen 'jo' irrelevant

> prüft == ob es sich bei den zu vergleichenden objekten um die selbe referenz handelt.

jo, wobei die Objekte ja nunmal Objekte sind,
aber die Variablen sind Referenzen auf Objekte und es wird nur geprüft, ob diese Referenzen dieselben sind


> das java feststellt wenn mehrere objekte erzeugt werden sollen, die gleich sind und dann das objekt nur einmal erstellt und einfach alle variablen auf das selbe objekt zeigen lässt.

nein, das klingt sehr falsch,

für die Ausnahme String mag das so sein:
String a = "ee";
String b = "ee";
// testweise mit == und equals vergleichen
dafür sorgt der Compiler beim Umsetzen dieser Sonder-Syntax

für
Integer c = Integer.valueOf(2);
Integer d = Integer.valueOf(2);
auch noch, Integer-Objekte werden (für kleine ints) gecacht, das sieht man schon halb an der Notation

aber im allgemeinen für 99.99999% aller Klassen sind
Person x = new Person("nach","oben");
Person y = new Person("nach","oben");
zwei unterschiedliche Objekte gleichen Inhalts, daher braucht man equals, == reicht nicht

 

[Janus]

wann muss ich bei objekten eigentlich den == operator benutzen bzw. wann equals.
- ==, wenn du auf identität prüfen willst, equals, wenn du auf inhaltliche gleichheit prüfen möchtest. in 95% aller fälle möchte man bei objekten equals verwenden

wenn ich ein objekt hab das null ist und ich prüfen möchte muss ich == nehmen (das hab ich durch trial & error festgestellt), da mir equals(null) eine Null-Pointer Exception liefert
- weil an objekten, die null sind, keine methoden aufrufen darfst/kannst

was ich so gelesen hab, prüft == ob es sich bei den zu vergleichenden objekten um die selbe referenz handelt. sprich ob die objekte wirklich identisch sind(speicheradresse).
- genau

gibts es daher nur 1 null objekt ? wenn ich ein objekt null setze und es auf null prüfe(mit ==), dann ergibt das ja eine wahre aussage.
- könnte man so sehen

aus der vorlesung hab ich "aufgeschnappt"(nicht wirklich verstanden) das java feststellt wenn mehrere objekte erzeugt werden sollen, die gleich sind und dann das objekt nur einmal erstellt und einfach alle variablen auf das selbe objekt zeigen lässt.
- wenn java das so macht (weiss ich nicht), dann allerdings transparent für den coder. es wäre tödlich, wenn der java compiler einfach mal so zwei unterschiedlich erzeugten objekten dieselbe identität verpasst. das muss schon auseinandergehalten werden können. wie das ganze gerümpel intern verwaltet wird, ist davon allerdings unabhängig.

 

[Guest]

aus der vorlesung hab ich "aufgeschnappt"(nicht wirklich verstanden) das java feststellt wenn mehrere objekte erzeugt werden sollen, die gleich sind und dann das objekt nur einmal erstellt und einfach alle variablen auf das selbe objekt zeigen lässt.

Das stimmt so sicher nicht (ausser ich hab nen oargen Brainbug)!
Also bei einem String-Objekt schon, aber nur wenn du es mit einem Literal instanziertst, sprich:

String s = "blub";
String a= "blub";

--> Es gibt im Speicher nur ein "blub" Literal auf welches dann beide Objekte zeigen, deshalb ist folgendes auch beides true:

s == a
s.equals(a)

Ansonsten wird schon jedes Objekt für sich erzeugt.

 

[Wolfram]

== null und der Vergleich von Referenzen ist ein Überrest der Zeigerarithmetik von C/C++.


== null:

Wenn eine Referenz auf kein Objekt "zeigt", setzt man sie null. Nun kann man von "keinem Objekt" natürlich keine Methode aufrufen, deshalb kann man für sowas keine Methode isNull schreiben, um auf diesen Fall abzuprüfen:

Object o = null;
if ( o.isNull() ) { ... }  // geht nicht!

Deshalb muss dieser Fall auf eine andere Art abgeprüft werden. Einige Programmiersprachen definieren eine Funktion dafür, isNull(), in Java und vielen anderen Programmiersprachen benutzt man == null.


Referenzvergleich:

Ich zäume es mal von hinten auf, ich verstehe sowas aus Maschinensicht immer viel leichter. (Achtung: Das folgende ist nur mehr ein Modell).

Eine Referenz ist quasi nur ein "Zeiger" in einen Speicherbereich. Stell Dir Deinen Speicher, in dem Deine Objekte abgelegt werden, als riesiges Array von x Gigabyte Größe vor. Dann ist ein Zeiger ist ein Index in diesem Array. Eine Referenz ist ein Zeiger, der grundsätzlich auf ein Objekt im Speicher zeigt, oder auf den Index 0 (null). In Java gibt es nur Referenzen, keine Zeiger, d.h. ein Java-Zeiger muss immer auf ein Objekt zeigen.

Wenn Du zwei Referenzen hast, die auf die gleiche Speicherstelle zeigen, ist auch das, was dort steht, also der "Wert" des Objektes gleich. Der Vergleich A == B tut dann, was man denken würde, die "Objekte sind gleich".

Aber:

Wenn Du zwei Referenzen hast, die auf unterschiedliche Speicherstellen zeigen, ist nicht gesichert, dass die Werte, die dort stehen, auch ungleich sind! Der Vergleich A == B vergleicht nur die Referenzen, nicht die Inhalte!

Deshalb brauchst Du, wenn Du wissen willst, ob die Inhalte gleich oder unterschiedlich sind, .equals.

   byte speicher[] = { 1, 2, 3, 1, 2 3 };
   int zeiger1 = 1, zeiger2 = 4;

   ...
      // entspricht ==
      ... zeiger1 == zeiger2 ...

      // entspricht .equals
      ... speicher[zeiger1] != speicher[zeiger2] ...

 

[SlaterB]

> Der Vergleich A == B tut dann, was man denken würde, die "Objekte sind gleich".

das ist doch irreführed bis falsch,
gleich sind zwei unterschiedliche Dinge mit gleichen (oder denselben ) Inhalt,
wenn man ein Ding ändert, dann sind sie nicht mehr gleich

aus A == B folgt aber, dass die beiden Objekte ein und dasselbe sind,
wenn man eins ändert, dann das andere auch, denn es ist ja nur eins

die Referenzen sind gleich (zwei unterschiedliche Referenzen gleichen Wertes), zeigen aber auf dasselbe Objekt

 

[Wolfram]

> Der Vergleich A == B tut dann, was man denken würde, die "Objekte sind gleich".

das ist doch irreführed bis falsch,
gleich sind zwei unterschiedliche Dinge mit gleichen (oder denselben ) Inhalt,
wenn man ein Ding ändert, dann sind sie nicht mehr gleich

aus A == B folgt aber, dass die beiden Objekte ein und dasselbe sind,
wenn man eins ändert, dann das andere auch, denn es ist ja nur eins

die Referenzen sind gleich (zwei unterschiedliche Referenzen gleichen Wertes), zeigen aber auf dasselbe Objekt

Ah natürlich, ich gehöre zu den Menschen, die ständig "das gleiche" und "das selbe" durcheinander bringen, aber damit kann man Referenzen natürlich auch super erklären. Bleibt die Frage - versteht das außer Dir dann noch wer?

Ich wollte nur die Maschinensicht noch schnell unterbringen, im Sinne der möglichst vielen Zugänge zu einem Thema.

 

[SlaterB]

wenn man erst deins liest, dann bestimmt, falls man danach noch genauer drüber nachdenken will

zur Ergänzung:
bei primitiven Variablen hat man keine 'dieselben' Einheiten, deren Werte sind immer unterschiedliche Dinge (Speicherstellen),
da sorgt == für einen Gleichheitstest
(im Grunde genau gleich wie bei den Objekten, da dort ja die Referenzen immer unterschiedliche Dinge sind (Speicherstellen) und deren Wert verglichen wird)

 

[usija]

hier mal der code einer methode die ein objekt aus einem array entfernt.

dort prüfe ich mit "==" ob mein "suchobjekt" mit einem key-wert übereinstimmt.

	/**
	 * Löscht ein Objekt aus der Tabelle.
	 * @param key Suchbegriff des Objektes, das gelöscht werden soll
	 * @return old Objekt das gelöscht wurde
	 */
	public Object remove(Object key)
	{
		Object old=null;
		/*Alle Elemente durchlaufen und prüfen ob es ein Objekt gibt,
		 * das dem übergebenen Schlüssel entspricht */ 
		for (int i=0; i < size; i++)
			if (data[i].getKey() == key) //Key des Elements entspricht Suchschlüssel
			{
				old = data[i].getValue(); //alten Wert sichern
				for (int j=i+1; j < size; j++, i++)
					data[i] = data[j];
				// Positionszähler dekrementieren
				size--;
				break;
			}
		
		return old;
	}

die schlüsselbegriff sind in diesem beispiel text-strings. und das funktioniert deswegen weil es eben literale sind, sehe ich das richtig? besser wäre es mit equals arbeiten?

 

[SlaterB]

richtig und wäre besser