# Object.equals() liefert falschen Wert?



## chaostheory (9. Dez 2012)

Hallo,
 so weit ich gelesen habe, vergleicht die Methode equals() bei Objekten, ob sie gleich sind, nicht ob sie identisch sind. Sprich der Inhalt wird verglichen, nicht der Speicherort.
Ich habe in einem Programm eine Klasse, die sieben Strings aus einer Website ausliest. In einem Test habe ich bestätigt, dass diese auch immer exakt gleich ausgelesen werden.
Wenn ich nun aber dieses Objekt in einer ArrayList speichere und in einem zweiten Aufruf den gleichen Eintrag neu auslese und mit contains() überprüfe, ob er schon in der ArrayList erhalte ich als Ergebnis false. Iteriere ich selbst über die Liste und mache bei jedem Objekt den equals-Vergleich erhalte ich bei einem true, da es ja schon gespeichert ist. Die ArrayList scheint also nicht wirklich den equals-Vergleich zu nutzen?

Grüße


----------



## TKausL (9. Dez 2012)

Verstehe ich grade nicht...
Hast du etwas Code?
Versuch mal contains() zu nutzen (auf die Liste).


----------



## tuttle64 (9. Dez 2012)

chaostheory hat gesagt.:


> Die ArrayList scheint also nicht wirklich den equals-Vergleich zu nutzen?



Wenn man einen Vergleich mit equals() macht, dann wird auch die ArrayList die Methode equals() benutzen. Bei Strings ist der Vergleich allerdings heikel. Kannst Du bitte Deinen Code posten. Das könnte vieles klären.


----------



## KSG9|sebastian (9. Dez 2012)

Warum sollte der Vergleich von Strings heikel sein?
ArrayList vergleicht genau was du erwartest: Beide Listen müssen dieselbe size() haben und die gleichen Elemente in derselben Reihenfolge haben.

Siehe http://docs.oracle.com/javase/1.4.2/docs/api/java/util/AbstractList.html#equals(java.lang.Object)


----------



## Spacerat (9. Dez 2012)

Tja... die ArrayList... wer weiss schon, was die bei "contains()" macht, ausser "indexOf()" aufzurufen und dessen Rückgabewert mit "-1" vergleichen. "indexOf()" selber verwendet dann "equals()" nur, wenn der übergebene Parameter (das zu testende Objekt) != null ist. Wenn "contains()" also nicht korrekt funktioniert, könnte es daran liegen, dass "indexOf()" überschrieben wurde. Wenn man nun aber feststellen will, ob eine Collection mehrere Elemente einer anderen Collection enthält, verwendet man "containsAll()". "equals()" würde, wie oben bereits gesagt grösstenteils "false" ergeben (wenn size und Reihenfolge nicht stimmen).


----------



## tröööt (9. Dez 2012)

@TO
das ist so nicht ganz korrekt ...

Obejct.equals(Object) ist mit "return this==obj" implementiert ... liefert als nur true wenn es ein und dasselbe objekt ist ...

es kommt immer auf die klasse an ob equals() überschrieben wird ... und wenn ja wie sinnvoll / logisch dies geschiet ...


----------



## chaostheory (10. Dez 2012)

Eine Sache, die sicher viele Missverständnisse beheben wird:
Besagt obj.equals() nun ob es ein und das selbe Objekt ist oder nur ob der Inhalt gleich ist? So wie ich das verstanden habe vergleicht equals() den Inhalt und == den Speicherort ???:L


----------



## TryToHelp (10. Dez 2012)

tröööt hat gesagt.:


> @TO
> das ist so nicht ganz korrekt ...
> 
> Obejct.equals(Object) ist mit "return this==obj" implementiert ... liefert als nur true wenn es ein und dasselbe objekt ist ...
> ...



Es kommt auf die implementierung deiner equals methode an, das 
	
	
	
	





```
==
```
 liefert immer dann true wenn es das identische Objekt ist, aber das equals je nachdem was implementiert ist. bei z.B. dieser 

```
public boolean equals(Object obj)
  {
   return true;
  }
```
wird immer true geliefert, und bei dieser immer false

```
public boolean equals(Object obj)
  {
   return false;
  }
```
Somit ist eine Aussage zu der Methode equals unbestimmt, beim Vergleichen ist nur sicher was 
	
	
	
	





```
==
```
 macht.


----------



## tröööt (10. Dez 2012)

wasw ich mit sagen wollte : wenn man sich nur Object.equals(Object) ansieht ... dann wäre es mit "this==object" implementiert ...
wenn man sich aber z.b. String.equals(String) ansieht wäre es so implementiert :

```
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
```
auch hier wird erstmal standardmäßig "this==obj" geprüft ... eigentlich könnte man hier auch super.equals(anObject) schreiben ... denn String erbt direkt von Object ...
dann wird geprüft ob das objekt ein string ist ...
wenn ja wird die länge verglichen ... und wenn die übereinstimmt das char-array selbst ...

ergo : String.equals(String) prüft :
1) ob es ein und dasselbe objekt ist
2) ob beide objekte vom type String sind
3) ob beide Strings die gleiche länge haben
4) ob der inhalt der char-arrays gleich ist ...


du redest hier aber von einer ArrayList
also schauen wir dort in den source und sehen : ArrayList hat selbst keine equals() methode ...
ArrayList leitet von AbstractList ab ... also schauen wir dort nach und finden das hier

```
public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof List))
            return false;

        ListIterator<E> e1 = listIterator();
        ListIterator e2 = ((List) o).listIterator();
        while (e1.hasNext() && e2.hasNext()) {
            E o1 = e1.next();
            Object o2 = e2.next();
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return !(e1.hasNext() || e2.hasNext());
    }
```
auch hier wird wieder erstmal mit "==" auf gleichheit geprüft ...
anders als bei String hat man sich hier dafür entschieden auf NOT-instanceof zu prüfen und dann mit false auszusteigen ... persönlich finde ich das hier keinen guten stil ... man hätte eher auf instanceof prüfen und dann den nachfolgenden code in den if-block packen sollen ... aber naja .. ist ne design entscheidung
dann wird mit ListIterator die List element für element durchgegangen und verglichen ...
hier sieht man auch das die elemente in der gleichen reihenfolge in der List stehen müssen ...
wenn also zwei List zwar den selben inhalt aber eine andere Reihenfolge haben sind diese laut AbstractList.equals() eben NICHT gleich ...
wenn die Iterator durch sind wird nun noch geprüft ob eine der listen noch ein zusätzliches element enthält ... also ob eine liste länger ist ... (auch hier wieder meine persönliche idee : hätte man vorher prüfen können) ... wenn das nicht der fall ist sind beide listen gleich lang und enthalten die selben elemente in der selben reihenfolge ...


da du nun auch noch von contains() spricht muss man sich dessen arbeitsweise auch genau so ansehen
ArrayList.contains(Object) sieht so aus:

```
public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
```
also : indexOf(Object) ansehen ...

```
public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
```
schlussendlich wird also doch wieder String.equals() aufgerufen was ja wie oben erwähnt bei "gleichem String" auch zu true führt und somit für indexOf() ein return größer "0" damit contains() true liefert ...

ergo : laut contains wären deine strings also nicht gleich
warum jetzt allerdings beim selbst durchlaufen und prüfen true kommt ..

hmm .. sehr interessantes problem ...

hier wäre wirklich mal etwas code angebracht ...


----------



## Spacerat (10. Dez 2012)

Glaskugel sagt: TO übergibt eine ArrayList an "contains()" statt an "containsAll()". Auf jeden Fall übergibt er an Contains keinen String der in der ArrayList enthalten ist.


----------



## HazelNut (14. Dez 2012)

Ja, hey ich push hier mal, da ich einen ähnlichen Fehler habe.

Habe eine ArrayList von Squares und wenn ich bei dieser abfragen möchte ob ein element enthalten ist erhalte ich nicht immer das korekte Ergebniss. Einmal bekomme ich ein true obwohl es nicht passt und einmal vica versa.
Dabei prüfe ich genau eine Zeile vor der contains(), welche Daten darin sind und, diese sind korrekt.

Die Klasse Square überschreibt equals und hashCode.


----------



## Spacerat (15. Dez 2012)

Diese "hashCode" und "equals" Methoden würde ich zu gerne mal sehen. Wenn sie viel anders als folgt aussehen, wird das nie was.

```
class ThisClass {
  public boolean equals(Object obj) {
    if(this == obj) {
      return true;
    }
    if(obj instanceof ThisClass) {
      boolean rc = false;
      // Inhalte vergleichen.
      // auf keinen Fall "return this.hashCode() == obj.hashCode();"!
      return rc;
    }
    return false;
  }

  public int hashCode() {
    int rc = 0;
    // hashCode mit den in equals verwendeten Inhalten
    // berechnen.
    // Vorsicht bei "toString().hashCode();". Dazu muss "toString();"
    // ebenfalls überschrieben werden, möglichst mit den in "equals()"
    // verwendeten Inhalten.
    return rc;
  }
}
```


----------



## HazelNut (16. Dez 2012)

Hmm nö habs so gemacht:


```
@Override
public boolean equals(Object obj) {
	boolean value = false;
	if (obj instanceof Square) {
		value = (this.getRow() == ((Square) obj).getRow());
		value = (this.getCol() == (((Square) obj).getCol()));
		return value;
	}
	return value;
}
	
@Override
public int hashCode() {
	return (row * col + row );
}
```

equals müsste passen und hashCode ... naja unwahrscheinlich, dass es für zwei Objekte mit unterschiedlichen werten der gleiche Wert ausspuckt .


----------



## Landei (16. Dez 2012)

[c]this.getRow() == ((Square) obj).getRow()[/c] funktioniert nur, wenn deine row ein primitiver Typ (int, long,...) ist. Ist sie ein Objekt, musst du natürlich [c]equals[/c] nehmen. Ist sie ein Array, musst du [c]java.util.Arrays.equals(array1,array2)[/c] verwenden.

Das eigentliche Problem mit dem Code ist, dass du value zweimal etwas zuweist, und beim zweiten Mal wird natürlich der alte Inhalt von value überschrieben. Nimm zwei unterschiedliche Variablen, und verknüpfe sie mit [c]&&[/c], denn Zeilen *und *Spalten müssen gleich sein.


----------



## HazelNut (16. Dez 2012)

col und row sind ints in dieser Klasse.

Weshalb mein value falsch sein soll verstehe ich irgendwie nicht so ganz.
Wenn es in der ersten Zeile zutrifft ist es true, wenn es in der zweiten Zeile unterschiedliche Werte sind wird es auf false gesetzt und auch so ausgegeben.
Das man es mit && machen kann ist klar nur sehe ich eben keinen Unterschied.

Bähhh, vergesst den obigen Text -_- Umgekehrt trifft es ja nicht zu.. :bloed:


----------

