闲逛Java的链表堆栈实现

Question

Does the concept of loitering exist in java's linked list stack implementation? Do I need to free memory by setting a node's contents to null before removing it from a linked list? Or is not doing so just as good because there isn't going to be any reference to my old first node anyway? Thanks!

public Item pop() {
    if (isEmpty()) 
        throw new StackEmptyException("Stack Empty");
    Item item = first.item;
    first.item = null;
    first = first.next;
    return item;
}

Answer 1

您的第二个语句是正确的-您无需清除节点，Java GC会处理它。

Answer 2

It does exist but it is unlikely you will need to worry about it.

In your case, after first = first.next the Java GC will recognise that the old node pointed at by first is now unreachable and so can be collected.

Answer 3

Let's say our Node looks like this

private class Node{
Item item;
Node next;
}

You don't have to assign null to first.item. When assigning first = first.next;, the first.next is a Node, which means it has both Item and the next Node.

Loitering is, holding a reference to an object when it is no longer needed. In your case you renew the reference, pointing to the next Item in the stack.

However, if we would use an array, our code would be:

public Item pop() {
return arrayItems[--N];
}

Here, we return an Item from the stack, but the pointer remains, pointing to the element we took of the stack. To avoid loitering, we set removed item entry to null:

public Item pop() {
Item item = arrayItems[--N];
arrayItems[N] = null;
return item;
    }