In Java, leere Sammlungen des gleichen Typs, aber unterschiedliche Typ Parameter immer gleich?

Question

Betrachten Sie das folgende Snippet:

List<String> list1 = new ArrayList<>(); 
    List<Integer> list2 = new ArrayList<>(); 
    assertThat(list1.equals(list2), is(true)); 

Die Behauptung folgt.

der Tat, soweit ich es verstehe, gibt es keine Möglichkeit in Java, für die equals Verfahren zwischen den beiden, aufgrund zu unterscheiden Typ-Löschung zu Laufzeit (dh die Tatsache, dass die Typargumente String und Integer sind nur zugänglich zur Kompilierzeit, aber nicht zur Laufzeit). Und da es keine Elemente gibt, die verglichen werden könnten, muss equals wahr zurückgeben. Und bei dieser Denkrichtung muss das für alle Sammlungen stimmen.

Also die Frage ist die folgende: Ist mein Denkprozess korrekt, oder fehlt mir etwas?

EDIT

@qqilihq ein ausgezeichnetes answer gab, die die nächste Frage aufgefordert: Ist dies möglich, ohne vorbei den Typen explizit zu erreichen (ich bin in Ordnung, wenn der Typ gespeichert ist ausdrücklich . irgendwie, nur der Benutzer hat sollte es nicht passieren müssen)

ich versucht, die folgenden, aber es hat nicht funktioniert (ich denke, durch Löschen geben):

public TypedList(List<T> delegate) { 
     this.delegate = Objects.requireNonNull(delegate); 
     this.type = (Class<T>) delegate.getClass(); 
    } 

Aber vielleicht können Sie etwas Ähnliches tun? this.type = T. (Dies wird nicht kompiliert, aber möglicherweise ist etwas Ähnliches möglich.)

Answer 1

Wie Sie feststellen, gehen die Typinformationen zur Laufzeit in Ihrem Beispiel verloren. Aber in Bezug auf Ihre Frage in den Kommentaren:

können Sie auch ein Gegenbeispiel, d. H. Eine Sammlung, wo zwei leere Instanzen von verschiedenen generischen Typen nicht als gleich behandelt werden?

Sie können natürlich implementieren Ihre eigenen Collection die tut berücksichtigen die Typinformationen in der equals Methode. Hier ist ein sehr einfaches Beispiel ein TypedList Wrapper um eine beliebige List erstellen:

static final class TypedList<T> extends AbstractList<T> { 
    private final List<T> delegate; 
    private final Class<T> type; 

    public TypedList(List<T> delegate, Class<T> type) { 
     this.delegate = Objects.requireNonNull(delegate); 
     this.type = Objects.requireNonNull(type); 
    } 

    @Override 
    public T get(int index) { 
     return delegate.get(index); 
    } 

    @Override 
    public int size() { 
     return delegate.size(); 
    } 

    @Override 
    public boolean equals(Object obj) { 
     if (!super.equals(obj)) { 
      return false; 
     } 
     // Lists are equal, now additionally, check the type 
     TypedList<?> other = (TypedList<?>) obj; 
     return this.type.equals(other.type); 
    } 

    // hashCode omitted for brevity 
} 

Beachten Sie, dass Sie benötigen den Typ explizit zu speichern, aufgrund der Art Löschung erwähnt. Verbrauch:

List<String> list1 = new ArrayList<>(); 
List<Integer> list2 = new ArrayList<>(); 
System.out.println(list1.equals(list2)); // true 

list1 = new TypedList<>(list1, String.class); 
list2 = new TypedList<>(list2, Integer.class); 
System.out.println(list1.equals(list2)); // false 

Answer 2

Es hängt wirklich davon ab, wie einzelne Untergruppe, die die Auflistungsschnittstelle implementieren, die equals() -Methode behandelt. Für Arraylist ist die Umsetzung in AbstractList welche wie folgt:

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()); 
} 

So einfach es wahr zurück, wenn das entgegengesetzte Objekt ist auch eine Liste und die Größe ist gleich und jedes Element ist gleich. Wenn also beide Listen leer sind, muss das Ergebnis wahr sein.

Answer 3

Generics für Typ verwendet bei der Kompilierung überprüfen.

Wenn Sie ArrayList wie folgt zu erstellen:

List<String> list1 = new ArrayList<>(); 
List<Integer> list2 = new ArrayList<>(); 
System.out.println(list1.equals(list2)); // result:true 

list1 und list2 wird gleich sein, weil sie leer sind. ArrayList verwendet intern Object[], um ArrayList Eintrag zu speichern.

Wenn Sie einige Eintrag in die Array-Liste hinzufügen:

List<String> list1 = new ArrayList<>(); 
list1.add("A"); 

List<Integer> list2 = new ArrayList<>(); 
list2.add(1); 

System.out.println(list1.equals(list2)); // result: false 

Diese false weil ArrayList Eintrag unterschiedlich sind