什么是链表与链表的实现。

1、链表与数组的区别

         我们都知道，如果一个数组想要在中间存一个元素，我们就要把后面的所有数据都往后挪一个，删除也是一样。这非常麻烦，而链表不需要。并且，数组在存储的时候申请的内存是连续的。比如你现在有1000块内存，但是不连续，那么你就存不了需要1000块内存的数组。但是链表可以。所以相比之下，链表能更加高效的利用内存！！

2、什么是链表？

       在《算法图解》一书中，是这样解释的（我认为通俗易懂！）。链表存数据如同寻宝游戏，你前往第一个地址，里面不仅有你想要的数据，而且还写着“下一个元素的地址为123”。因此，你前往地址123，那里又告诉你下一个地址在哪里。以此类推，在链表中添加元素很容易，只需将其放入内存，并且将其地址存储到前一个元素中。

3、怎么向链表中添加或删除元素

       图中@后面即是地址（框框上面的粗体字为本元素的地址，框框里面的为指向的下一个地址），若想添加元素，只需要将上一个的地址指向新添加的，并且新添加的元素指向下一个地址即可~~删除也一样，只需要直接将“删除元素”的前一个元素的地址直接指向“删除元素”的后一个元素的地址即可！

 4、链表的增删等功能实现！

实现的功能（方法）：代码段中注释很详细！

1. public void clear()：清空单向链表

2. public boolean isEmpty() :判断链表是否为空，是返回true，否返回false

3. public int length()：获取链表中元素的个数

4. public T get(int i )：读取并返回链表中的第i个元素的值

5. public int indexOf(T t)：返回链表中首次出现的指定的数据元素的位序号

6. public void insert(T t)：在链表中添加一个元素

7. public void insert(int i,T t)：在链表的第i个元素之前插入一个值为t的数据元素

8. public T remove(int i )：删除并返回链表中第i个数据元素

9. public void showList()：显示链表所有节点的数据

import java.util.Objects;
public class linkedList <T>{     //linkedList接口，存泛型
    private Node head;       //属性1节点
    private int length;     //属性2长度
    //构造器
    public linkedList() {
        //初始化头节点
        this.head = new Node(null,null);
        //初始化元素个数
        this.length = length;
    }
    /**
     * Node类里面有存的数据（泛型 T），和下一个地址
     */
    public class Node{
        T date;
        Node nextNode;
        public Node(T date, Node nextNode) {   //构造方法
            this.date = date;
            this.nextNode = nextNode;
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node node = (Node) o;
            return Objects.equals(date, node.date);
        }

        @Override
        public int hashCode() {
            return Objects.hash(date);
        }
    }
    /**
     * 清空链表
     */
    public void clear(){
        head.nextNode = null;   //下一个节点为空
        this.length = 0;      //长度为0
    }
    /**
     * 判断链表是否为空，是返回true，否返回false
     */
    public boolean isEmpty(){
        return length == 0;
    }
    /**
     * 获取链表中元素的个数
     */
    public int length(){
        return length;
    }

    /**
     *
     * @param i 读取并返回链表中的第i个元素的值
     * @return T
     */
    public T get(int i) {
        Node node = head.nextNode;   //节点指向第一个链表块
        for (int j = 0; j < i; j++) {     //循环遍历直到到i
            node = node.nextNode;      //将i前面的地址指向给node
        }
        return node.date;
    }
    /**
     * 返回链表中首次出现的指定的数据元素的位序号
     * @return  位序号
     */
    public int indexOf(T t){
        Node node = head;
        for (int i=0;node.nextNode!=null;i++){   //只要下一个地址不为空
            node = node.nextNode;            //就一直将下一个地址赋值给node
            if(node.date.equals(t)){       //直到找到node的数据等于要找的数据
                return i;           //返回下标
            }
        }
        return -1;
    }
    /**
     * 在链表中添加一个元素
     */
    public void insert(T t){
        //找到最后一个节点
        Node node = head;
        while (true){
            if(node.nextNode == null){   //直到下一个地址为空，就跳出循环
                break;
            }
            node = node.nextNode;          //否则一直获取下一个地址
        }
        //创建新的节点
        Node newNode = new Node(t,null);
        //将新的节点存入最后一个节点
        node.nextNode = newNode;
        length++;
    }
    /**
     * 在链表的第i个元素之前插入一个值为t的数据元素
     */
    public void insert(int i ,T t){
        Node temp = head;
        for(int j=0;j<i;j++){
            temp = temp.nextNode; //i的前一个下标
        }
        Node node1 = temp.nextNode;//i的现下标
        Node node2 = new Node(t,node1); //新的数据指向i的现下标
        temp.nextNode = node2;    //新的数据又赋给i前面的数据的下一个地址
        length++;
    }
    /**
     * 删除并返回链表中第i个数据元素
     */
    public T delete(int i) {
        //1.找到i位置的前一个节点
        Node temp = head;
        for(int index = 0;index<i;index++){
            temp = temp.nextNode;
        }
        //2.找到i位置的节点
        Node currNode = temp.nextNode;
        //3.找到i位置的后一个节点
        Node nextNode = currNode.nextNode;
        //4.i位置的前一个节点指向i位置的后一个节点
        temp.nextNode = nextNode;
        //5.元素个数减1
        length--;
        return currNode.date;
    }
    /**
     * 显示链表所有节点的数据
     */
    public void showAll(){
        if(length==0){
            System.out.println("链表为空！");
        }
        Node node = head;
        for(int i=0;i<length;i++){
            node = node.nextNode;
            System.out.println(node.date);
        }
    }
}

/**
 * 测试一下
 */
class Test{
    public static void main(String[] args) {
        linkedList<String> list = new linkedList<>();   //实例化
        //在链表中添加一个元素
        list.insert("白日梦想家");
        list.insert("哈哈哈哈");
        list.insert("无人生还");
        list.insert("摩托车");
        list.insert("进大厂！");
        //判断链表是否为空，是返回true，否返回false
        System.out.println((list.isEmpty())?"链表为空！":"链表不为空。");
        //获取链表中元素的个数
        System.out.println("链表中有"+list.length()+"个元素");
        //读取并返回链表中的第i个元素的值
        System.out.println("获取到的元素为"+list.get(0));
        //返回链表中首次出现的指定的数据元素的位序号
        System.out.println("链表中首次出现位置："+list.indexOf("哈哈哈哈"));
        //在链表的第i个元素之前插入一个值为t的数据元素
        list.insert(2,"我是新添加的");
        //删除并返回链表中第i个数据元素
        System.out.println("成功删除"+list.delete(3));
        //显示链表所有节点的数据
        System.out.println("遍历结果：");
        list.showAll();
        System.out.println("清空列表");
        list.clear();
        list.showAll();
    }
}

你都看完了，如果对你有帮助！那就点个赞吧！

若还有疑问，可以私信问我，我都会一一解答！！