java - 链接列表程序不会删除对象，并且会因未知原因抛出强制转换异常？

Question

我正在编写一个基本的链表程序。为了测试它，我刚刚创建了一个基本的列表，添加了一堆东西，然后尝试删除它们。它抛出了一个我不理解的错误。

程序:

public static void main(String[] args) {
    OrderedLinkedList one = new OrderedLinkedList();
    for(int i = 0; i<=20; i=i+2){
        one.add(i);
    }
    one.remove(3);
    //System.out.println(one.toString());

}

我想看看如果我尝试删除一个不存在的对象会发生什么。但是当我这样做时，它抛出了这个异常:

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

异常似乎发生在包含 compareTo() 方法的行中的删除方法中。我如何尝试将 int 转换为字符串？当 3 传递给方法时不应该是一个可比较的值吗？

public boolean add(Comparable obj)
    {
        if(head.next == null){
        OrderedListNode newNode = new OrderedListNode(obj, head, tail);
        }
        else{
            OrderedListNode newNode = new OrderedListNode(obj,tail.previous,tail);
            tail.previous.next = newNode;
            tail.previous = newNode;
        }
        return true;
    }

    public boolean remove(Comparable obj)
    {
        OrderedListNode temp = head;
        while(temp != null){
            if(temp.theItem.compareTo(obj) == 0){
                temp.previous.next = temp.next;
                temp.next.previous = temp.previous;
            }
            else{
                temp = temp.next;
            }
        }
        return true;
    }
/**
 *  Empty this OrderedLinkedList.
 */
public void clear()
{
    // reset header node
    head = new OrderedListNode("HEAD", null, null);

    // reset tail node
    tail = new OrderedListNode("TAIL", head, null);

    // header references tail in an empty LinkedList
    head.next = tail;

    // reset size to 0
    theSize = 0;


}
private class OrderedListNode{
    Comparable theItem;
    OrderedListNode next;
    OrderedListNode previous;

    public OrderedListNode(Comparable theItem, OrderedListNode previous, OrderedListNode next){
        this.theItem = theItem;
        this.next = next;
        this.previous=previous;
    }
}
@Override
public String toString()
{
    String s = "";

    OrderedListNode currentNode = head.next;

    while (currentNode != tail)
    {
        s += currentNode.theItem.toString();

        if (currentNode.next != tail)
        {
            s += ", ";
        }

        currentNode = currentNode.next;
    }

    return s;
}

Answer 1

你的问题出在 clean 方法上。它正在实例化字符串数据类型节点并将其放入尾部和头部。因此，当调用remove()时，当它在命中字符串类型节点时迭代/循环对象列表时，会抛出异常，因为它试图将int与string进行比较。

无论如何，我已经通过重新编写部分代码解决了您的问题。它并不完美，但至少不再遇到问题

以下是更改。

第一个:在删除方法中 - 您将需要一个break语句，否则代码可能会进入无限循环。

第二:我已经修改了您的 Clean 方法，因为它包含一些逻辑错误。基本上，您需要在清理期间将内容设置为 null 或 0，而不是为其初始化新的尾部和头部对象。

第三:添加逻辑也有点不正确，逻辑上是明智的。我也对其进行了重新设计。

注意:由于时间限制，我没有真正测试自己的更改，因此可能仍然存在错误，这些错误不属于此问题的范围。

如果发现任何错误，请回复消息，我会抽时间再看一下。

public class OrderedLinkedList {

    OrderedListNode head = null;
    OrderedListNode tail = null;
    int theSize = 0;

    public boolean add(Comparable obj)
    {
        if(head == null){
            head = new OrderedListNode(obj, head, tail);
        }
        else{
            OrderedListNode newNode = new OrderedListNode(obj, /*prev=*/tail, /*next=*/null);
            if (tail == null)
                head.next = newNode;
            else {
                tail.next = newNode;
                // tail.previous = newNode; No need this line. Already set in constructor
            }

            tail = newNode;
        }
        return true;
    }

    public boolean remove(Comparable obj)
    {
        OrderedListNode temp = head;
        boolean elemRemoved = false;
        while(temp != null){
            if(temp.theItem.compareTo(obj) == 0) {
                // dereference this object for garbage collection
                if (temp.previous != null)
                    // Not a head - Head will not have previous
                    temp.previous.next = temp.next;
                temp.next.previous = temp.previous;
                elemRemoved = true;
                break;
            }
            else{
                temp = temp.next;
            }
        }
        return elemRemoved;
    }
    /**
     *  Empty this OrderedLinkedList.
     */
    public void clear()
    {
        // reset header node
        head = null;

        // reset tail node
        tail = null;

        // header references tail in an empty LinkedList
        //head.next = tail;

        // reset size to 0
        theSize = 0;


    }
    private class OrderedListNode{
        Comparable theItem;
        OrderedListNode next;
        OrderedListNode previous;

        public OrderedListNode(Comparable theItem, OrderedListNode previous, OrderedListNode next){
            this.theItem = theItem;
            this.next = next;
            this.previous=previous;
        }
    }
    @Override
    public String toString()
    {
        String s = "";

        OrderedListNode currentNode = head.next;

        while (currentNode != tail)
        {
            s += currentNode.theItem.toString();

            if (currentNode.next != tail)
            {
                s += ", ";
            }

            currentNode = currentNode.next;
        }

        return s;
    }

}


public class main {


    public static void main(String[] args) {
        OrderedLinkedList one = new OrderedLinkedList();
        one.clear();
        for(int i = 0; i<=20; i=i+2){
            one.add(i);
        }
        boolean removedOK = one.remove(3);
        System.out.println("Attempt 1 : Something was removed => " + removedOK);

        removedOK = one.remove(2);
        System.out.println("Attempt 2: Something was removed => " + removedOK);

        removedOK = one.remove(4);
        System.out.println("Attempt 3: Something was removed => " + removedOK);

    }

}