java 实现单向链表

节点类

package singlyLinkedList.demo;

public class Node {

    private Object data;

    private Node nextNode;

    public Node(Object data) {
        super();
        this.data = data;
    }

    public Node getNextNode() {
        return nextNode;
    }

    public void setNextNode(Node nextNode) {
        this.nextNode = nextNode;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

}

链表类

package singlyLinkedList.demo;

public class SinglyLinkedList {

    private Node first = null;
    private Node last = null;
    private int size = 0;

    // 插入一个元素
    public void add(String value) {
        Node newNode = new Node(value);// 新节点
        // 对象赋值对象,传递的是对象的值(包含对象地址,所以被赋值的对象被修改会根据地址修改原对象)
        Node tempNode = last;// 创建临时节点对象赋值上一次存入的节点对象,如果没有插入过则为null
        last = newNode;// 将新的节点对象赋值为最后插入节点
        if (tempNode == null) {// 上一次存入的节点为null,表示没有存入过节点
            first = newNode;// 将新插入的节点赋值给第一个节点对象
        } else {
            tempNode.setNextNode(newNode);// 将新节点对象赋值到上一个节点的next节点对象
        }
        size++;
    }

    // 将元素插入指定位置
    public void add(Integer index, String value) {
        if (index < 0) {
            System.out.println();
            System.err.println("超出容器范围");
        } else if (index > size - 1) {
            System.out.println();
            System.err.println("超出容器范围");
        }
        Node newNode = new Node(value);// 新节点

        if (index == size - 1) {// 刚好是最后一个的情况

            // 对象赋值对象,传递的是对象的值(包含对象地址,所以被赋值的对象被修改会根据地址修改原对象)
            Node tempNode = last;// 创建临时节点对象赋值上一次存入的节点对象,如果没有插入过则为null
            last = newNode;// 将新的节点对象赋值为最后插入节点
            if (tempNode == null) {// 上一次存入的节点为null,表示没有存入过节点
                first = newNode;// 将新插入的节点赋值给第一个节点对象
            } else {
                tempNode.setNextNode(newNode);// 将新节点对象赋值到上一个节点的next节点对象
            }
        } else {
            // 根据索引遍历节点
            Node prev = null;
            Node next = null;
            Node current = first;// 从第一个节点开始找
            for (int i = 0; i < size; i++) {
                if (i == index) {
                    next = current;// 找出被插入位置的节点
                    break;
                }
                prev = current;
                current = current.getNextNode();
            }
            prev.setNextNode(newNode);
            newNode.setNextNode(next);

        }
        size++;
    }

    // 获取装载数
    public Integer size() {
        return size;
    }

    // 通过下标获取一个元素
    public String get(Integer index) {
        if (index < 0) {
            System.out.println();
            System.err.println("超出容器范围");
        } else if (index > size - 1) {
            System.out.println();
            System.err.println("超出容器范围");
        }
        // 根据索引遍历节点
        Node current = first;
        for (int i = 0; i < size; i++) {
            if (i == index) {
                break;
            } else {
                current = current.getNextNode();
            }
        }
        return (String) current.getData();
    }

    // 通过下标删除一个元素
    public void remove(Integer index) {
        if (index < 0) {
            System.out.println();
            System.err.println("超出容器范围");
        } else if (index > size - 1) {
            System.out.println();
            System.err.println("超出容器范围");
        }
        // 根据索引遍历节点
        Node prev = null;
        Node current = first;
        if (index == 0) {
            if (size > 1) {
                first = first.getNextNode();
            } else {
                first = null;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (i == index) {
                    break;
                }
                prev = current;
                current = current.getNextNode();
            }
            prev.setNextNode(current.getNextNode());
            if (current.equals(last)) {
                last = prev;
            }
            current = null;
        }
        size--;
    }

    // 通过元素删除自己
    public void remove(String value) {
        // 根据索引遍历节点
        Node prev = null;
        Node current = first;
        if (first.getData().equals(value)) {
            if (size > 1) {
                first = first.getNextNode();
            } else {
                first = null;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (current.getData().equals(value)) {
                    break;
                }
                prev = current;
                current = current.getNextNode();
            }
            prev.setNextNode(current.getNextNode());
            if (current.equals(last)) {
                last = prev;
            }
            current = null;
        }
        size--;
    }

}

执行类

package singlyLinkedList.demo;

public class Main {

    public static void main(String[] args) {
        String stemp;
        Integer itemp;
        SinglyLinkedList sl = new SinglyLinkedList();

        sl.add("a");
        System.out.println("sl.add(\"a\");");
        itemp = sl.size();
        System.out.println("sl.size(): " + itemp);
        stemp = sl.get(0);
        System.out.println("sl.get(0): " + stemp);

        sl.add("b");
        System.out.println("sl.add(\"b\");");
        itemp = sl.size();
        System.out.println("sl.size(): " + itemp);
        stemp = sl.get(1);
        System.out.println("sl.get(1): " + stemp);

        sl.add("c");
        System.out.println("sl.add(\"c\");");
        itemp = sl.size();
        System.out.println("sl.size(): " + itemp);
        stemp = sl.get(2);
        System.out.println("sl.get(2): " + stemp);

        sl.add("d");
        System.out.println("sl.add(\"d\");");
        itemp = sl.size();
        System.out.println("sl.size(): " + itemp);
        stemp = sl.get(3);
        System.out.println("sl.get(3): " + stemp);

        sl.add("e");
        System.out.println("sl.add(\"e\");");
        itemp = sl.size();
        System.out.println("sl.size(): " + itemp);
        stemp = sl.get(4);
        System.out.println("sl.get(4): " + stemp);

        sl.add(3, "f");
        System.out.println("sl.add(3, \"f\");");
        itemp = sl.size();
        System.out.println("sl.size(): " + itemp);
        stemp = sl.get(2);
        System.out.println("sl.get(2): " + stemp);
        stemp = sl.get(3);
        System.out.println("sl.get(3): " + stemp);
        stemp = sl.get(4);
        System.out.println("sl.get(4): " + stemp);
        stemp = sl.get(5);
        System.out.println("sl.get(5): " + stemp);

        sl.remove(5);
        System.out.println("sl.remove(5);");
        itemp = sl.size();
        System.out.println("sl.size();" + itemp);
        stemp = sl.get(4);
        System.out.println("sl.get(4): " + stemp);
        sl.add("g");
        System.out.println("sl.add(\"g\");");
        stemp = sl.get(5);
        System.out.println("sl.get(5): " + stemp);

        sl.remove("a");
        System.out.println("sl.remove(\"a\");");
        itemp = sl.size();
        System.out.println("sl.size();" + itemp);
        stemp = sl.get(4);
        System.out.println("sl.get(4): " + stemp);
        sl.add("i");
        System.out.println("sl.add(\"i\");");
        stemp = sl.get(5);
        System.out.println("sl.get(5): " + stemp);

    }

}

执行结果
sl.add(“a”);
sl.size(): 1
sl.get(0): a
sl.add(“b”);
sl.size(): 2
sl.get(1): b
sl.add(“c”);
sl.size(): 3
sl.get(2): c
sl.add(“d”);
sl.size(): 4
sl.get(3): d
sl.add(“e”);
sl.size(): 5
sl.get(4): e
sl.add(3, “f”);
sl.size(): 6
sl.get(2): c
sl.get(3): f
sl.get(4): d
sl.get(5): e
sl.remove(5);
sl.size();5
sl.get(4): d
sl.add(“g”);
sl.get(5): g
sl.remove(“a”);
sl.size();5
sl.get(4): g
sl.add(“i”);
sl.get(5): i