java实现单向链表（已泛型方式进行存储任意对象）

以工具类的思想，进行设计存储任意类型的单向链表

该链表实现对节点元素的增，删，修改，查找，但通常这种类型的数据结构一般的应用场景为对数据的增添与删除；先说明一下设计过程中特别注意的小细节：

1.每次改变节点的大小时，不要忘记对其size值进行修改；add()方法，size++,remove()方法，size--;

2.循环查找索引值的节点是，注意迭代的方式，进行更精准的思考，在第一次实现遍历所有节点时，直接在循环内打印System.out.print("printNode.next.value"),则永远只打印第一个节点的内容。

3.每次在循环内查找节点，i++一定不能忘，否则会抛java.lang.NullPointerException异常。

代码如下：

在更改成员位置的权限修饰符，还未进行测试，因为在同一个类中进行编写，不会涉及权限的问题。在最后的主方法中进行了各个方法的测试，成功完成。

class MyLinked<T> {
    private class Mynode<T>{
        //未在此处设置该成员变量的权限修饰符
        private T value;
        private Mynode<T> next;
        public Mynode(){
        }
        public Mynode(T value){
            this.value = value;
        }

    }
    private Mynode head;
    private  int size;
    public MyLinked(){
        this.head = new Mynode();
        this.size = 0;
    }
    //向整个链表的末尾添加一个新节点
    public void add(T value){
        int i=0;
        //该链表的结构是索引从0开始,直接寻找最后一个节点即可
        Mynode<T> lastNode = head;
        while (i<size){
            lastNode = lastNode.next;
            i++;
        }
        Mynode newNode = new Mynode<T>(value);
        lastNode.next = newNode;
        size++;
    }
    public void add(int index,T value){
        if(index ==size){
            add(value);
            return;
        }
        //检测索引是否正常取值
        checkIndex(index);
        //寻找该索引的前一个节点
        Mynode<T> preNode = head;
        int i =0;
        while (i<index){
           preNode = preNode.next;
           i++;
        }
        Mynode<T> newNode = new Mynode<>(value);
        newNode.next = preNode.next;
        preNode.next = newNode;
        size++;
    }
    public void remove(int index){
        checkIndex(index);
        Mynode<T> preNode = head;
        int i =0;
        while(i<index){
            preNode = preNode.next;
            i++;
        }
        preNode.next = preNode.next.next;
        size--;
    }
    public void set(int index,T value){
        Mynode<T> setNode = head;
        int i =0;
        while (i<=index){
            setNode = setNode.next;
            i++;
        }
        setNode.value = value;
    }
    public T getNode(int index){
        checkIndex(index);
        Mynode<T> getNode = head;
        int i =0;
        while (i<=index){
            getNode=getNode.next;
            i++;
        }
        return getNode.value;
    }
    public void print(){
        int i =0;
        Mynode<T> printNode = head;
        while (i<size){
            printNode = printNode.next;
            System.out.print(printNode.value +" ");
            i++;
        }
        System.out.println();

    }
    public void checkIndex(int index){
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("下标越界"+index);
        }
    }
}

public class LinkedDemo {
    public static void main(String[] args) {
        MyLinked<Integer> link = new MyLinked();
        link.add(12);
        link.add(13);
        link.add(2,14);
        link.add(16);
        link.set(3,15);
        link.add(16);
        link.print();
        link.remove(4);
        link.print();
        System.out.println(link.getNode(3));
        //访问超过链表索引的节点元素，抛出指针异常
        System.out.println(link.getNode(4));
    }
}