On Fri, 9 Dec 2022 18:35:57 GMT, John Hendrikx <jhendr...@openjdk.org> wrote:
>> It's safe as you're never actually using the type `E`, but I suppose the 2nd
>> list can also be `List<?>` as only `equals` is called on it. The 2nd
>> `ListIterator` would then also be `ListIterator<?>`.
>>
>> Casting to a specific generic type (like `List<E>`) never verifies if all
>> the elements are of that type, you're just telling the compiler that they
>> are.
>>
>> Only when you do something like:
>>
>> E e = list.get(0);
>>
>> ... you may get a CCE here (but the compiler allowed it because you casted
>> it to `List<E>` earlier). That's why I say it is safe because the follow up
>> code does not do any such action (it in fact does `Object o2 = e2.next()` --
>> it would be bad if it was `E o2 = e2.next`).
>>
>> Looking at it again, I think making the 2nd `List` a `List<?>` is better, as
>> we don't know yet at that stage that they all are of type `E` (even though
>> it doesn't matter for the code following it).
>
> It also removes the need for the `SuppressWarnings` here.
I suggest the following method:
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof List<?> list)) {
return false;
}
if (size() != list.size()) {
return false;
}
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = list.listIterator();
while (e1.hasNext() && e2.hasNext()) {
if (!Objects.equals(e1.next(), e2.next())) {
return false;
}
}
return true;
}
Technically, there's no need to check `hasNext` on both since they have the
same length, but it doesn't matter.
I also don't like the names `e1` and `e2` for list iterators :)
-------------
PR: https://git.openjdk.org/jfx/pull/969
