day_8/11(自己实现一个LinkedList)

一、目的

前面面讲了LinkedList的概述及用法，为了更好的理解LikedList的实现原理，所以现在我们自己来实现一个LinkedList。

二、分析

要实现一个LinkedList，第一步就是实现List接口，随后再去实现功能。

LinkedList是通过链式结构来存储元素的，所以我们存储数据就不能和ArrayList一样使用数组了，而是用链表来实现，那么问题来了链表是什么？

        链表就是由多个节点串起来的，这就是链表。链表又分单向链表和双向链表，单向链表的每个节点由数据和下一个节点的地址组成，双向链表的每个节点在单向链表的基础上还有前一个节点的地址。今天我们暂且使用单向链表来实现自己的LinkedList集合。

知道了链表是由节点连起来的，那节点又是什么呢？
（在我们写代码的人眼中，节点其实就是一个Node类），所以我们可以每个节点可以抽象成一个类，这个类的一个对象就是一个节点

现在有了节点，数据放在节点里面，那还需要些什么东西呢？集合里存了多少个元素是不是需要一个变量来存储？定义一个变量啰。

        暂且用到这些东西，一个节点类，用于在我们自己实现的LinkedList集合里面存放数据，一个变量，用于存放元素个数。下面请看具体实现。

三、实现

        1、节点类Node

public class Node {

    public Object data;
    //节点类的书写很简单，只需要一个Object类型的变量用来存放数据
    //为什么这里是Object类而不是其他类呢？我们又不知道存的是什么
    //对象，而Object是所有类的父类，所以之后存什么对象都可以。
    
    public Node next;
    //还需要一个变量用来存放下一个节点的地址，下一个节点对象不也是Node类，
    //所以这里用的是Node类型

    //变量定义好之后，Node类就写好了啊，后面给它们赋值，直接用对象名 . 变量名即可
    //全参构造没有写的必要了，因为后面创建对象用的也是无参构造
    //而无参构造在没有其他构造函数的时候系统会自动提供，所以也没写的必要
}

 

 

        2、size方法

       前面说了，我们这么直到集合存储了多少个元素呢？是不是定义了一个变量来存储元素的数量，那么size方法只需要返回这个变量的值不就可以了，看代码

//用于记录元素个数
    int count;
    @Override
    public int size() {
        return this.count;
    }

       前面使用的ArrayList集合是使用数组存储的元素，可以直接使用下标来控制元素的添加位置，那链表如何控制操作元素的的位置呢？我们可以使用一个指针p来指向某个元素，随后就可以进行增删改查等操作了。看如下一段代码。

//把p移动到指定位置
for (int i = 0; i <=index ; i++) {
            p = p.next;
        }

       3、add方法

add方法就是用来添加元素的，可以不带索引，直接默认添加在集合尾部，也就是集合最后一个元素，还有就是带索引的add方法，把元素添加到指定的位置，而不是添加到集合的尾部，有了思路，那链表如何添加节点呢？先看一个图片，再看代码实现：

 

 

@Override
    public boolean add(Object o) {
        //因为添加到元素尾部也是需要移动指针p到链表尾部
        //所以直接调用带索引的方法，随后传入元素的个数，
        //即把元素添加到了集合尾部
        add(count,o);
        return true;
    }

    @Override
    public void add(int index, Object element) {
        //进入方法首先就得判断传入的额参数是否可以操作
        //这里我们就先判断索引是否越界，这里我是把越
        //界的索引修改为元素的个数，即把元素添加到集合尾部
        if(index > count){
            index = count;
        }
        //创建一个节点用于存储元素
        Node node = new Node();
        node.data = element;
        //创建指针从头节点开始
        Node p = head;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        //先把p指针的下一个节点用新节点存起来，随后再用p指针
        // 指向的节点来存储新节点的引用地址，这样就完成了元素的添加
        node.next = p.next;
        p.next = node;
        //元素增加一个之后，元素的数量也要加一
        count++ ;
    }

 看看测试：

public class MainTest {
    public static void main(String[] args) {
        //创建一个自己定义的集合对象
        MyLinkedList myLinkedList = new MyLinkedList();
        //添加元素之前集合的长度
        System.out.println(myLinkedList.size());
        myLinkedList.add("111");
        myLinkedList.add("222");
        myLinkedList.add("333");
        myLinkedList.add("444");
        myLinkedList.add("555");
        myLinkedList.add(1,"666");
        //添加元素之后集合的长度
        System.out.println(myLinkedList.size());
    }
}

运行结果：

 

 结果很明显，添加六个元素之后，集合的长度变为六了，即元素添加成功。

       4、get方法

元素添加之后，我们怎么来查看元素呢？get方法就可以实现这个功能，实现get方法很简单，我们只需要把指针移动需要获取的元素那里，是不是就可以通过指针里获取元素内容了，看实现代码：

@Override
    public Object get(int index) {
        //和add方法一样的操作，创建指针节点，
        // 从头节点开始，移动到需要操作的节点的位置
        Node p = head;
        for (int i = 0; i <=index ; i++) {
            p = p.next;
        }
        return p.data;
    }

 测试代码：

//get方法测试
        //获取单个元素
        System.out.println(myLinkedList.get(3));
        //遍历元素列表
        for (int i = 0; i < myLinkedList.size(); i++) {
            System.out.println(myLinkedList.get(i));
        }

运行结果： 

       5、remove方法

        remove方法如何实现呢？它有两种方式移除元素啊，根据元素，根据索引，首先根据元素来删，那我们是不是先要从集合里面找，看集合里面有没有这个元素，如果有的话才删，没有的话删个屁啊，之后根据索引来删呢？就简单了，把指针移动到对应的索引处，随后删除就可以了，有了思路，那链表如何删除一个节点呢？先看一个图片，再看代码实现：

@Override
    public boolean remove(Object o) {
        //根据元素来删除节点
        Node p = head;
        //根据元素个数控制循环次数
        for (int i = 0; i < count; i++) {
            //判断当前节点的下一个节点是否是我们要删除的那个元素
            if ((o).equals(p.next.data)){
                //如果是要删除的节点还要判断要删除的节点是不是最后一个节点
                //两种情况删除方式不一样
                if (p.next.next != null){
                    p.next = p.next.next;
                }else{
                    p.next = null;
                }
                //删除元素后元素数量减一
                count--;
                return true;
            }else{
                //不是要删的元素则指针往后移动
                p = p.next;
            }
        }
        return false;
    }
    
    @Override
    public Object remove(int index) {
        //判断索引有没有越界
        if(index> count){
            System.out.println("索引越界了，不予删除");
            return null;
        }
        Node p = head;
        //移动指针
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        //存储要删除的元素，因为remove方法规定了返回值
        Object o = p.data;
        if (p.next.next != null){
            p.next = p.next.next;
        }else{
            p.next = null;
        }
        //删除元素后元素数量减一
        count--;
        return o;
    }

来看一下测试代码： 

//remove方法测试
        System.out.println("");
        myLinkedList.remove(333);
        myLinkedList.remove(4);
        //删除元素后再遍历以下集合，看看是否删除成功
        for (int i = 0; i < myLinkedList.size(); i++) {
            System.out.println(myLinkedList.get(i));
        }

 运行结果：

对比删除前后的集合遍历结果，发现两种方式元素都删除成功。 

       6、set方法

最后来看看set方法，set方法很好实现，移动指针到需要修改的位置，随后操作即可：看如下一段代码：

@Override
    public Object set(int index, Object element) {
        if (index > count){
            System.out.println("索引越界了，不予修改");
            return element;
        }
        Node p = head;
        Node node = new Node();
        for (int i = 0; i <= index; i++) {
            p = p.next;
        }
        Object o = p.data;
        p.data = element;
        return o;
    }

测试代码如下：

//set方法测试
        //现在把剩余的四个元素中的第三个元素修改为"888"
        System.out.println("-----分界线-----");
        myLinkedList.set(2,888);
        //修改之后再次遍历输出
        for (int i = 0; i < myLinkedList.size(); i++) {
            System.out.println(myLinkedList.get(i));
        }

运行结果：

 观察运行结果，发现修改成功。

以上就是自己实现一个简易版的LinkedList的全部过程了，感谢阅读，嘿嘿。