单链表也是最基本的一个数据类型，相对比较简单。
如果有任何疑问欢迎来探讨。

首先是节点数据

package ListExercise;

public class Node<T> {
    // 下一个节点
    public Node<T> next;
    // 任意数据类型
    public T data;

    // 初始化数据
    public Node(T t) {
        this.data = t;
        next = null;
    }
}

接下来是我们的核心代码

package ListExercise;

public class LinkedList<T> {

    // 头结点
    private Node<T> headNode;
    // 链表长度
    private int size;

    // -1是头节点，没有数据
    public LinkedList() {
        size = 0;
        headNode = new Node<T>(null);
    }

    // 添加元素data
    public boolean add(T data) {
        boolean ret = false;
        Node<T> node = getHide(this.size - 1);
        node.next = new Node<T>(data);

        size++;
        ret = true;
        return ret;
    }

    // 添加元素data
    public boolean insert(int index, T data) {
        boolean ret = false;
        Node<T> node = getHide(index - 1);
        Node<T> nextNode = node.next;
        node.next = new Node<T>(data);
        node.next.next = nextNode;

        size++;
        ret = true;
        return ret;
    }

    // 删除元素data
    public boolean remove(T data) {
        boolean ret = false;
        Node<T> a = headNode;
        while (a.next != null) {
            if (a.next.data == data) {
                a.next = a.next.next;
                ret = true;
                break;
            }
            a = a.next;
        }
        size--;
        return ret;
    }

    // 删除元素data
    public boolean removeAt(int index) {
        boolean ret = false;
        if (index >= 0 && index < size) {
            Node<T> a = headNode;
            int i = -1;
            while (i < index - 1) {
                a = a.next;
                i++;
            }
            size--;
            a.next = a.next.next;
        } else {
            throw new RuntimeException("超出数据范围:" + index);
        }

        return ret;
    }

    // -1是头节点，没有数据
    public Node<T> get(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("超出数据范围:" + index);
        }

        return getHide(index);
    }

    // -1是头节点，没有数据
    private Node<T> getHide(int index) {
        int i = -1;
        Node<T> ret = headNode;
        while (i < index) {
            ret = ret.next;
            i++;
        }
        return ret;
    }

    public void print() {
        Node<T> t = headNode;
        int i = 0;
        while (t.next != null) {
            t = t.next;
            System.err.println(t.data);
            i++;
            if (i > 100)
                break;
        }
        System.err.println("长度为：" + i);
    }
}

最后是测试的代码：

package ListExercise;

public class Main {
    public static void main(String[] args) {

        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        for (int i = 0; i < 10; i++) {
            linkedList.add(i);
        }

        linkedList.print();
        linkedList.insert(10,10);
        linkedList.remove(1);
        linkedList.removeAt(0);

        linkedList.print();
    }
}

最后，双向链表和循环链表和单链表基本差不多就不一一举例了。