通用单链表的实现

Question

New to the site. Trying to implement a generic SinglyLinkedList, fetch returns null even though there are nodes in and delete method return false, when true is expected. In addition, it functions just fine when I decide to delete in reverse order. Looking for a set of fresh eyes to see what I am missing. Thanks-in-advance.

public class SinglyLinkedList<T> {

    private Node<T> h;  // list header

    public SinglyLinkedList() {
        h = new <T> Node();  // dummy node
        h.l = null;
        h.next = null;
    }

    public boolean insert(T newNode) {
        Node n = new Node();
        GenericNode node = (GenericNode) newNode;
        if (node == null) // out of memory
        {
            return false;
        } else {
            n.next = h.next;
            h.next = n;
            n.l = (T) node.deepCopy();
            return true;
        }
    }

    public GenericNode fetch(Object targetKey) {
        Node p = h.next;
        GenericNode node = (GenericNode) p.l; // this is where am I think there is a problem. Is this right? 
        while (p != null && !(node.compareTo(targetKey) == 0)) {
            p = p.next;
        }
        if (p != null) {
            return node.deepCopy();
        } else {
            return null;
        }
    }

    public boolean delete(Object targetKey) {
        Node q = h;
        Node p = h.next;
        GenericNode node = (GenericNode)p.l;// I think is the problem
        while (p != null && !(node.compareTo(targetKey) == 0)) {
            q = p;
            p = p.next;
        }
        if (p != null) {
            q.next = p.next;
            return true;
        } else {
            return false;
        }
    }

    public boolean update(Object targetKey, T newNode) {
        if (delete(targetKey) == false) {
            return false;
        } else if (insert(newNode) == false) {
            return false;
        }
        return true;
    }

    public void showAll() {
        Node p = h.next;
        while (p != null) //continue to traverse the list
        {
            System.out.println(p.l.toString());
            p = p.next;
        }
    }

    /**
     *
     * @param <T>
     */
    public class Node <T> {

        private T l;
        private Node <T> next;

        public <T> Node() {
        }
    }// end of inner class Node
    }
//end SinglyLinkedList outer class

Answer 1

The problem lies here (in fetch method):

    GenericNode node = (GenericNode) p.l; // this is where am I think there is a problem. Is this right? 
    while (p != null && !(node.compareTo(targetKey) == 0)) {
        p = p.next;
    }

You assing node only only before entering the loop, and only change p value inside the loop, so node keeps its initial value throughout the whole loop. You should use:

    GenericNode node = null;      // define node before the loop in order to use it later
    while (p != null) {
        node = (GenericNode) p.l; // reset node value on each iteration
        if (node.compareTo(targetKey) == 0) {
            break;
        }
        p = p.next;
    }

As you have same code in delete , the same fix will apply...