单向链表的实现

链表是一种线性表，但不会按线性的顺序存储数据，而是在每一个节点里存储下一个节点的指针。一个单链表的节点分为2部分，一部分称为数据域，存储节点数据信息，另一部分称为指针域，存储下一个节点的指针。
节点类的实现代码如下：

public class Node {
    Object data;
    Node next;
    public Node (Object obj) {
        this.data = obj;
    }
}

单链表的基本操作包含插入节点，删除节点，查找节点等。
单链表类的实现代码如下：

public class SingleLinkedList {
    // 链表长度
    public int size;
    // 链表头节点
    public Node head;
    public SingleLinkedList() {
        size = 0;
        head = null;
    }
    /**
     * 向链表头部插入节点
     * @param obj 待插入节点的数据域
     * @return 返回新链表的头节点
     */
    public Node addHead(Object obj) {
        Node node = new Node(obj);
        if (size == 0) {
            head = node;
        } else {
            node.next = head;
            head = node;
        }
        size++;
        return head;
    }

    /**
     * 向链表尾部插入一个节点，支持链式调用
     * @param obj 待插入节点的数据域
     * @return 返回当前链表对象
     */
    public SingleLinkedList append(Object obj) {
        Node node = new Node(obj);
        if (size == 0) {
            head = node;
        } else {
            Node currentNode = head;
            while (currentNode.next != null) {
                currentNode = currentNode.next;
            }
            currentNode.next = node;
        }
        size++;
        return this;
    }

    /**
     * 删除头结点
     * @return 返回新的头结点
     */
    public Node removeHead() {
        if (size == 0) {
            return null;
        }
        head = head.next;
        size--;
        return head;
    }

    /**
     * 删除指定数据域节点
     * @param obj 待删除节点的数据域
     * @return 返回删除的结果（成功或失败）
     */
    public boolean removeNode(Object obj) {
        if (size == 0) {
            return false;
        }
        Node currentNode = head;
        Node previousNode = head;
        while (currentNode.data != obj) {
            if (currentNode.next != null) {
                previousNode = currentNode;
                currentNode = currentNode.next;
            } else {
                return false;
            }
        }
        if (currentNode == head) {
            head = currentNode.next;
        } else {
            previousNode.next = currentNode.next;
        }
        size--;
        return true;
    }

    /**
     * 查找指定数据域的节点
     * @param obj 节点的数据域
     * @return 返回待查找的节点
     */
    public Node findNode(Object obj) {
        if (size == 0) {
            return null;
        }
        int tempSize = size;
        int currentNode = head;
        while (tempSize > 0) {
            if (currentNode.data == obj) {
                return currentNode;
            } else {
                currentNode = currentNode.next;
                tempSize--;
            }
        }
        return null;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 打印链表节点信息
     */
    public void show() {
        if (size > 0) {
            int tempSize = size;
            Node currentNode = head;
            if (tempSize == 1) {
                System.out.print("[" + currentNode.data +"]");
                return;
            }
            while (tempSize > 0) {
                if (currentNode == head) {
                    System.out.print("[" + currentNode.data + "->");
                } else if (currentNode.next == null) {
                    System.out.print(currentNode.data + "]");
                } else {
                    System.out.print(currentNode.data + "->");
                }
                currentNode = currentNode.next;
                tempSize--;
            }
        } else {
            System.out.print("[]");
        }
    }
}