使用java实现单链表底层代码，关键代码位置都有详细的注释说说明

java实现链表结构原理

简单的单链表

首先这是一个简单的链表增加元素功能
两个类 ListNode 和 LinkedMain，运行代码使用main方法。

ListNode代码

public class ListNode {

    public int data;
    public ListNode next;

    public ListNode(int data){
        this.data = data;
    }

    public ListNode(){
        System.out.println("-->"+data);
    }

    // 增加链表元素
    public void add(int newdata){
        ListNode nowNode = new ListNode(newdata);
        // this.next表示一个新的ListNode对象，内存地址和其他的不同
        if(this.next == null){
            this.next = nowNode;
        }else {
            this.next.add(newdata);
        }
    }

    // 打印链表
    public void print(){
        System.out.println(this.data);
        System.out.println(this.next.data + "--" + this.next.next);
        if(this.next!=null){
            System.out.println("-->");
            this.next.print();
        }
    }
}

LinkedMain类代码

public class LinkedMain {
    public static void main(String[] args) {
        ListNode node = new ListNode();
        node.add(2);
        node.add(3);
        node.add(4);
        node.add(5);
        node.print();
    }
}

使用链表实现增删查改

准备三个类 Student实体类，Singlinkedlist实现类，linkedMain运行方法
方法中都有详细的注释说明，如果有不清楚的尝试多dug几次，看看链表中元素的变化以及内存地址的变化，这个很重要

Student类

public class Student {
    public int Id;
    public String name;
    public int score;
    public Student next;

    public Student(int id, String name, int score) {
        this.Id = id;
        this.name = name;
        this.score = score;
    }

    //从写toSting方便查看数据（不能将next域输出，不然会出现嵌套）
    @Override
    public String toString() {
        return "Student{" +
                "Id=" + Id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

}

Singlinkedlist类

public class Singlinkedlist {

    // 创建头节点
    Student head  = new Student(0,"",0);

    // 链表添加过程
    public void addStudent(Student student){
        // 为了不改变头节点，创造一个临时变量
        // 将new Student 出来的内存地址 head 赋值给temp， 这样head和temp地址都指向同一个内存空间
        Student temp = head;
        while (true){
            // 判断没有下一个节点后，直接走temp.next = student，将传参赋值给下一个节点，也就是最后一个节点
            if(temp.next == null) {
                break;
            }
            // 将当前的下一个节点（temp.next）重新赋给temp，
            // 然后再此进入循环，再次判断节点是否有下一个节点
            temp = temp.next;
        }
        // 循环的目的是为了找到最后一个节点，如果最后一个节点没有下一个节点（next）,
        // 就将student赋值给最后一个节点
        temp.next = student;
    }

    // 根据id查找
    public void selectStudent(int id){
        Student temp = head;
        // true表示找到，false没找到
        boolean flag = false;
        // 遍历链表
        while (true){
            // 当地址为空时，表示整个链表以遍历完
            if(temp.next == null){
                break;
            }
            // 找到指定id
            if(temp.next.Id == id){
                flag = true;
                break;
            }
            // 获取下一个节点
            temp = temp.next;
            if(flag){
                System.out.println("找到了"+temp);
            }else {
                System.out.println("改节点不存在");
            }
        }
    }

    public void updateStudent(Student student){
        Student temp = head;
        // true表示找到，false没找到
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.Id == student.Id){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.next.name = student.name;
            temp.next.score = student.score;
            System.out.println("修改成功");
        }else {
            System.out.println("修改节点不存在");
        }
    }

    // 删除节点
    public void deleteStudent(int Id){
        Student temp = head;
        boolean flag = false;
        while (true){
            if(temp.next == null){
                break;
            }
            if(temp.next.Id == Id){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            // 用下一个节点的内容，替换当前节点，那么当前节点就不存在，相当于被删除了
            temp.next = temp.next.next;
        }
    }

    // 将链表中数据打印出来
    public void list(){
        Student temp = head;
        // 循环获取temp的next，每次获取到的temp都是不一样的内存地址
        while(true){
            if(temp.next == null){
                break;
            }
            // 获取当前对象的next赋值给temp，
            temp = temp.next;
            System.out.println(temp);
        }

    }
}

linkedMain 类

public class linkedMain {

    public static void main(String[] args) {
        Student s1 = new Student(1001, "张三", 90);
        Student s2 = new Student(1002, "李四", 80);
        Student s3 = new Student(1003, "王五", 88);
        Student s4 = new Student(1004, "赵六", 78);

        Singlinkedlist list = new Singlinkedlist();
        list.addStudent(s1);
        list.addStudent(s2);
        list.addStudent(s3);
        list.addStudent(s4);
        // 展示链表中的所有数据
        list.list();
        //删除学生1001
        System.out.println("删除1001");
        list.deleteStudent(1001);
        list.list();
        System.out.println("修改赵六为小六，分数改为99");
        list.updateStudent(new Student(1004, "小六", 99));
        list.list();
        System.out.println("查询");
        list.selectStudent(1003);
    }
}