定义链表（链表）

 定义int型链表

public class ListNode {
    int val; //数据：节点数据
    ListNode next; //对象：引用下一个节点对象，

    //添加构造方法
    ListNode(int val){//构造方法：构造方法和类名相同
        this.val = val; //把接收到的参数赋值给当前类的val变量
    }
}

定义泛型链表

public class ListNode<E> {
    E val; //数据：节点数据
    ListNode next; //对象：引用下一个节点对象，

    //添加构造方法
    ListNode(E val){//构造方法：构造方法和类名相同
        this.val = val; //把接收到的参数赋值给当前类的val变量
    }
}

创建链表以及遍历链表

static class Test_{
        //静态声明在内部类中是不允许的
        public static void main(String[] args) {
            //创建首节点
            ListNode nodeSta = new ListNode(0);
            //声明一个变量用来在移动过程中指向当前节点
            ListNode nextNode;
            //指向首节点
            nextNode = nodeSta;

            //创建链表(长度为10)
            for (int i = 1; i <10 ; i++) {
                //生成新节点
                ListNode node = new ListNode(i);
                //连接新节点
                nextNode.next = node;
                //把当前节点往后移动
                nextNode = nextNode.next;
            }//当循环完毕后，nextNode指向最后一个节点
            //重新赋值让移动节点指向首节点
            nextNode = nodeSta;
            //打印输出
            print(nextNode);
        }
        static void print(ListNode listNode){
            //创建链表节点
            while (listNode!=null){
                if(listNode.next==null){
                    System.out.print(listNode.val);
                }else {
                    System.out.print(listNode.val + "->");
                }
                listNode = listNode.next;
            }
        }
    }

 输出结果：0->1->2->3->4->5->6->7->8->9

插入链表

//插入节点
            while(nextNode!=null){
                //这里因为之前使用的示范型定义的链表，因此需要规定val的数据类型为int
                if((int)nextNode.val==5){
                    ListNode newnode = new ListNode(99);
                    //保存下一个节点
                    ListNode node = nextNode.next;
                    //插入新节点
                    nextNode.next = newnode;
                    //新节点的下一个节点指向之前保存的节点
                    newnode.next = node;
                }
                nextNode=nextNode.next;
            }//循环之后，nextNode指向第一个节点
            nextNode =nodeSta;
            print(nextNode);
        }
        //打印输出
        static void print(ListNode listNode){
            //创建链表节点
            while (listNode!=null){
                if(listNode.next==null){
                    System.out.print(listNode.val);
                }else {
                    System.out.print(listNode.val + "->");
                }
                listNode = listNode.next;
            }
        }

输出结果： 0->1->2->3->4->5->99->6->7->8->9

替换节点

//替换节点
            while(nextNode!=null){
                if ((int)nextNode.val==4){
                    //生成新的节点
                    ListNode newnode = new ListNode(98);
                    //保存替换节点的下一个节点
                    ListNode node = nextNode.next.next;
                    //将替换节点指向null，等待垃圾回收
                    nextNode.next.next = null;
                    //将当前节点指向新节点
                    nextNode.next = newnode;
                    //将节点指向原来的替换节点的下一个节点
                    newnode.next = node;
                }
                //移动当前节点
                nextNode = nextNode.next;
            }

 输出结果：0->1->2->3->4->98->99->6->7->8->9

删除节点

//删除节点
            while(nextNode!=null){
                if ((int)nextNode.val==3){
                    //保留当前节点的下一个节点的指向节点
                    ListNode node = nextNode.next.next;
                    //将当前节点的下一个节点指向null，等待垃圾回收
                    nextNode.next.next = null;
                    //将当前节点指向保留的节点
                    nextNode.next = node;
                }
                //移动节点向后移动
                nextNode = nextNode.next;
            }

输出结果：0->1->2->3->98->99->6->7->8->9