如何在泛型类型转换中删除未选中的转换警告

Question

我正在堆栈中实现一个列表链接。该程序成功通过了所有必需的测试，但我遇到了此警告。程序的实现没有中断，但我正在寻求消除此问题。你能告诉我如何通过编辑Equals方法中的代码来修复它吗？未选中的强制转换：“java.lang.对象”到“LinkedStack”

public final class LinkedStack<E> implements Stack<E> {

private Node head = null;
private int size = 0;

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

@Override
public boolean isEmpty() {
    return size == 0;
}

@Override
public void clear() {
    head = null;
    size = 0;
}

@Override
public boolean contains(E e) {
    for (int i = 0; i < size; i++) {
        E temp = pop();
        if (temp.equals(e)) {
            return true;
        }
    }
    return false;
}

@Override
public E top() throws StackEmptyException {
    if (size == 0) {
        throw new StackEmptyException();
    }
    return head.element;
}

@Override
public void push(E e) {
    head = new Node(e, head);
    size++;
}

@Override
public E pop() throws StackEmptyException {

    if (size == 0) {
        throw new StackEmptyException();
    }
    E temp = head.element;
    head = head.next;
    size--;
    return temp;
}


public boolean equals(Object o) {
    if (o == null || getClass() != o.getClass()) return false;
    LinkedStack<E> that = (LinkedStack<E>) o;
    if (that.size() != this.size()) return false;
    Node j = that.head;
    int counter = 0;
    for (Node i = head; counter < size; i = i.next, j = j.next) {
        if (i.element == null && j.element == null) {
            counter++;
            continue;
        }
        if ((i.element != null) && (j.element != null)) {
            if (!i.element.equals(j.element)) {
                return false;
            }
        } else {
            return false;
        }
        counter++;
    }
    return true;
}

@Override
public int hashCode() {
    int resultat = 1;
    int counter = 0;
    for (Node i = head; counter < size; i = i.next) {
        if (i.element == null) {
            counter++;
            continue;
        }
        resultat = resultat * i.element.hashCode();
        counter++;
    }
    return resultat;
}


protected class Node {
    private final E element;
    private final Node next;

    protected Node(final E element, final Node next) {
        this.element = element;
        this.next = next;
    }
}


}

Answer 1

我刚刚意识到原则上可以避免显式转换到LinkedStack

至于这会造成什么不同-转换到LinkedStack

这就是“禁止未经检查的强制转换警告”的其他答案的意思，当他们说除非绝对必要，否则最好避免未经检查的强制转换。

（我有意避免对所提供代码的其余部分发表评论）