纯手写LinkedList集合

要想明白LinkedList的底层原理和手写LinkedList就先理解下链表和数组的区别吧！

一.数组：

1. 数组是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素空间(就像上一篇手写List里的ArrayList一样，删除后有一个空余的空间)，然后将要增加的元素放在其中。同样的道理，如果想要删除一个元素，同样需要移动大量元素去填掉被移动的元素。如果应用需要快速访问数据，很少插入和删除元素，就应该用数组。

2. 在使用前需要提前申请所占用内存的大小，这样不知道需要多大的空间(ArrayList用到了扩容技术，涉及到需要把旧数组中的所有元素向新数组中搬移),预先申请可能会浪费内存空间，即数组空间利用率低

3. 在数组的起始位置处，插入数据和删除数据效率低。因为在插入数据时，待插入位置的元素和它后面的所有元素都需要向后移动；删除元素的时候也需要把待删除元素后面的所有元素都向前搬移

4. 随机访问效率很高，时间复杂度可以达到O(1),因为数组的内存是连续的，想要访问元素，直接从数组的首地址处向后偏移就可以访问

5. 数组的空间是从栈分配的

二.链表：

1. 链表中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起，每个节点包括两个部：一个存储数据元素的数据域，另一个是存储下一个节点地址指针。如果要访问链表中的元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素就需要用到链表。

2. 在内存中，元素的空间可以在任意地方，空间是分散的，不需要连接

3. 在链表中的元素都会有两个属性，一个是元素的值，另一个是指针，此指针标记了下一个元素的地址

4. 查找数据时效率低，时间复杂度为O(N),因为链表的空间是分散的，所以不具有随机访问性，如果需要访问某个位置的数据，需要从第一个数据开始找起，依次遍历(后面代码的getNode方法充分体现)。

5. 空间不需要提前指定大小，是动态申请的，根据需要动态申请和删除内存空间，扩展方便，所以空间利用率较高

6. 任意位置插入元素和删除元素效率高，时间复杂度为O(1)

7. 链表的空间是从堆中分配的

下面看代码实现LinkedList(部分)：

package org.robert.mylist;

import java.util.LinkedList;
import java.util.Objects;

/**
 * @Description 纯手写LinkedList
 * @author: 甘华
 * @联系方式 1766848439@qq.com
 * @date: 2019/2/16 21:06
 * @version: 1.0
 */
public class MyLinkedList<E> {

    //链表实际储存元素
    private transient int size;
    //第一个元素(头节点，为了查询开始)
    private transient Node first;
    //最后一个元素(为了添加开始)
    private transient Node last;

    public int size() {
        return size;
    }

    /**
     * 增加元素
     *
     * @param e
     */
    public void add(E e) {
        //创建一个节点
        Node node = new Node();
        //给节点赋值
        node.object = e;
        if (first == null) {
            //添加第一个节点
            first = node;
            last = node;
        } else {
            //添加第二个及以上数据
            node.prev = last;
            //将上一个的元素的next赋值
            last.next = node;
        }
        //为最后一个节点赋值
        last = node;
        //实际长度
        size++;
    }

    /**
     * 按照指定索引插入元素
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        //下标的验证
        checkPositionIndex(index);
        //node2节点
        MyLinkedList<E>.Node oldNode = getNode(index);
        if (oldNode != null) {
            //node1
            MyLinkedList<E>.Node oldPrevNode = oldNode.prev;
            //新增node节点
            Node newNode = new Node();
            newNode.object = e;
            //下一个节点为node2
            newNode.next = oldNode;
            if (oldPrevNode == null) {
                first = newNode;
            } else {
                //node4上一个节点为node1
                newNode.prev = oldPrevNode;
                //node1下一个节点为node
                oldPrevNode.next = newNode;
            }
            //node2的上一个节点为node4
            oldNode.prev = newNode;
            size++;
        }
    }

    /**
     * 按照下标查询
     *
     * @param index
     * @return
     */
    public Object get(int index) {
        //下标的验证
        checkPositionIndex(index);
        /**
         * 为什么说LinkedList的个体效率低？
         * 主要是因为get的时候需要逐个遍历来获取匹配的节点内容
         * ArrayList是直接操作数组的，get也是直接在数组里面根据索引获取的。
         */
        return getNode(index).object;
    }

    /**
     * 按照索引替换对象
     *
     * @param index
     * @param e
     * @return
     */
    public Object set(int index, E e) {
        //获取需要替换的Node节点
        Object obj = getNode(index).object;
        //替换
        getNode(index).object = e;
        //返回目标以前值
        return obj;
    }

    /**
     * 按照下标获得节点
     *
     * @param index
     * @return
     */
    public Node getNode(int index) {
        //下标验证
        checkPositionIndex(index);
        Node node = null;
        if (first != null) {
            //默认取第0个
            node = first;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
        }
        return node;
    }


    /**
     * 按照指定位置删除
     *
     * @param index
     */
    public void remove(int index) {
        //下标的检查
        checkPositionIndex(index);
        //先获取当前删除node节点
        MyLinkedList<E>.Node oldNode = getNode(index);
        if (oldNode != null) {
            //获取删除元素的上下节点
            //node3
            MyLinkedList<E>.Node oldNextNode = oldNode.next;
            //node1
            MyLinkedList<E>.Node oldPrevNode = oldNode.prev;
            //将node1的下一个节点变为node3
            if (oldPrevNode == null) {
                //删除第一元素从新换头
                first = oldNextNode;
            } else {
                oldPrevNode.next = oldNextNode;
                oldNode.prev = null;
            }
            //将node3的上一个节点变为node1
            if (oldNextNode == null) {
                last = oldPrevNode;
            } else {
                oldNextNode.prev = oldPrevNode;
                oldNode.next = null;
            }
            oldNode.object = null;
            //让垃圾回收机制处理
            size--;
        }
    }

    /**
     * 返回节点对象obj在链表中首次出现的位置，如果没有就返回-1
     *
     * @param obj
     * @return
     */
    public int indexOf(Object obj) {
        /**
         * 首先判断first==null.如果为null就表示没有元素
         * 在判断first==obj,如果为obj就直接返回
         */
        if (Objects.isNull(first)) {
            return -1;
        } else {
            //查询匹配返回值
            for (int i = 0; i < size; i++) {
                Object node = getNode(i).object;
                if (node.equals(obj)) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 下标越界验证抛出异常
     *
     * @param index
     */
    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException("下标超出,最大下标:" + (size - 1));
    }

    /**
     * 下标检查
     *
     * @param index
     * @return
     */
    private boolean isPositionIndex(int index) {
        return index >= 0 && index < size;
    }

    /**
     * 链表节点存储元素
     */
    private class Node {
        /**
         * 节点内容
         */
        private Object object;
        /**
         * 上一个节点
         */
        private Node prev;
        /**
         * 下一个节点
         */
        private Node next;
    }

}