Java LinkedList迭代器：为什么它们只返回对象？

在这里，我将发布我的代码：

    int len = InternalList.size();

    ListIterator<E> forward = InternalList.listIterator( 0 );
    ListIterator<E> backward = InternalList.listIterator( len );
    while( forward.hasNext() && backward.hasPrevious() )
    {
        E next = forward.next();
        E prev = backward.previous();

        // When the object references are the same, we expect to be at the
        // center of the list (for odd-numbered lists?); we're done
        if( next == prev )
            return true;

        // Otherwise, if the object values aren't the same, we're not a
        // palindrome
        if( !((E)next).equals( prev ) )
            return false;
    }

int len=InternalList.size（）；
ListIterator forward=InternalList.ListIterator（0）；
ListIterator向后=InternalList.ListIterator（len）；
while（forward.hasNext（）&&backward.hasPrevious（））
{
E next=前进。下一步（）；
E prev=backward.previous（）；
//当对象引用相同时，我们希望
//列表的中心（对于奇数列表？）；我们完成了
如果（下一个==上一个）
返回true；
//否则，如果对象值不相同，我们就不是
//回文的
如果（！（（E）下一个）。等于（上一个））
返回false；
}

以下是内部列表：

private LinkedList<E> InternalList;

私有链接列表内部列表；

---

所以基本上我的问题是最后一个if语句只检查对象的equals（）方法；不是E的等号（）。如果强制强制强制转换不起作用，怎么办？

从迭代器返回的元素的运行时类型不会（实际上也不能）更改。它们被分配给

E

类型的字段，这些字段在运行时可能会被擦除到

对象中（取决于通用边界），但这不会影响对象本身

调用
equals（）
时，它是一个非静态方法，因此无论
下一个
对象的类是什么，都会调用它。如果此类没有重写的equals方法，那么请确定，将使用默认的
对象.equals
。但是，如果此对象的类直接或间接重写等于，则将使用最特定的重写

换句话说，这段代码应该是很好的（而且完全不需要强制转换）

我建议您再次检查您是否在所讨论的类中正确重写了
equals
。我猜您已经将其实现为：

public class MyFoo {
    ...
    public boolean equals(MyFoo other) {
       ...
    }
}

而参数必须是Object类型，否则只会重载equals方法而不是重写它。如果您使用的是Java 6，则可以将
@Override
注释添加到方法中，这将捕获此类错误。
从迭代器返回的元素的运行时类型不会（实际上也不能）更改。它们被分配给
E
类型的字段，这些字段在运行时可能会被擦除到
对象中（取决于通用边界），但这不会影响对象本身

调用
equals（）
时，它是一个非静态方法，因此无论
下一个
对象的类是什么，都会调用它。如果此类没有重写的equals方法，那么请确定，将使用默认的
对象.equals
。但是，如果此对象的类直接或间接重写等于，则将使用最特定的重写

换句话说，这段代码应该是很好的（而且完全不需要强制转换）

我建议您再次检查您是否在所讨论的类中正确重写了
equals
。我猜您已经将其实现为：

public class MyFoo {
    ...
    public boolean equals(MyFoo other) {
       ...
    }
}

而参数必须是Object类型，否则只会重载equals方法而不是重写它。如果您使用的是Java 6，您可以将
@Override
注释添加到方法中，这将捕获此类错误。
由于运行时多态性，将在运行时选择
equals（Object）
的正确实现。你为什么不这么认为

实际上，您可能犯了一个常见错误，实现了
equals（ASpecificType）
而不是
equals（Object）
：您希望覆盖
java.lang.Object
中的
equals（Object）
方法。指定不同的参数类型意味着您不再重写该方法

ASpecificType
的常见
equals（）
实现可以这样开始：

public boolean equals(Object o) {
  if (this==o) {
    return true;
  } else if (o==null || o.getClass() != getClass()) {
    return false;
  }
  ASpecificType other = (ASpecificType) other;
  // insert specific comparison here
  return result;
}

由于运行时多态性，将在运行时选择
equals（Object）
的正确实现。你为什么不这么认为

实际上，您可能犯了一个常见错误，实现了
equals（ASpecificType）
而不是
equals（Object）
：您希望覆盖
java.lang.Object
中的
equals（Object）
方法。指定不同的参数类型意味着您不再重写该方法

ASpecificType
的常见
equals（）
实现可以这样开始：

public boolean equals(Object o) {
  if (this==o) {
    return true;
  } else if (o==null || o.getClass() != getClass()) {
    return false;
  }
  ASpecificType other = (ASpecificType) other;
  // insert specific comparison here
  return result;
}

该角色将
E
转换为
E
，因此它什么也不做
equals
应在不使用强制转换的情况下工作
正如您在评论中发布的那样，
next==prev
对于偶数列表不起作用
关于如何实现
等于
：

public boolean equals(Object o) {
  if(this == o) { return true; }
  if(o == null) { return false; }
  if(o instanceof [ClassOfThis]) {
    o = (Type)o;
    // compare here.
  } else {
    return false;
  }
}

该角色将
E
转换为
E
，因此它什么也不做
equals
应在不使用强制转换的情况下工作
正如您在评论中发布的那样，
next==prev
对于偶数列表不起作用
关于如何实现
等于
：

public boolean equals(Object o) {
  if(this == o) { return true; }
  if(o == null) { return false; }
  if(o instanceof [ClassOfThis]) {
    o = (Type)o;
    // compare here.
  } else {
    return false;
  }
}

是的，我知道我可以优化偶数列表PIt不是一个优化，它是一个修复，除非访问元素两次是无害的……除非我们讨论的是大型列表或性能需求，我的意思是。是的，我知道我可以对偶数列表进行优化：PIt不是一个优化，它是一个修复，除非访问元素两次是无害的…除非我们谈论的是巨大的列表或性能需求，我的意思是。它确实有一个。但调试器步骤告诉我，这仍然要通过对象的equals（）方法完成。到目前为止我只知道这些，它确实有一个。但调试器步骤告诉我，这仍然要通过对象的equals（）方法完成。到目前为止，这就是我所知道的。发布
的+1等于