手动实现List集合(ArrayList、LinkedList) 数组扩容和双向链表

---

模拟实现List集合

个人理解，大佬勿喷！为了巩固集合的基础，模拟一下List集合的实现过程(ArrayList和LinkedList都是线程不安全的，Vector实现步骤和ArrayList差不多，只是多了同步的操作，这里不做实现)

特别注意

这个手动实现的ArrayList和LinkedList的查询和删除都是 以当前第某个元素来操作，源码中以下标为第某个元素来操作的 。想要实现一样的，可以根据源码改。例如：查询第1个，手动：存入的以一个元素，源码：下标为1的元素。

直接上代码，名称有些是自定义的，逻辑和源码基本差不多(部分逻辑没有写)，整体影响不大。

一、ArrayList实现

private final static int INIT_CAPACITY = 10; // 初始容量

private static Object[] INITIAL_DEFAULT_CONTENT = {}; // 初始默认内容

private Object[] elementData; // 存放数据的容器

private static int size; // 数组长度

/**
 * 无参构造器，默认赋值为空数组
 */
public AutoArrayList() {
    this.elementData = INITIAL_DEFAULT_CONTENT; // {}
}

/**
 * 指定大小构造器
 * @param capacityLength 指定大小
 */
public AutoArrayList(int capacityLength) {
    // 参数大于0则按参数创建数组
    if(capacityLength > 0){
        this.elementData = new Object[capacityLength];
    }
    else if(capacityLength == 0){
        // 参数等于0 则将默认空数组赋值给容器
        this.elementData = INITIAL_DEFAULT_CONTENT; // {}
    }
    else{
        // 参数小于 0 则抛出异常
        throw new RuntimeException("初始化异常");
    }
}

/**
 *
 * @param e 需要添加的元素
 * @return 返回是否添加成功
 */
@Override
public boolean add(E e) {
    int min = calcCapacity(size+1); // 计算最小容量
    checkCapacity(min); // 检查是否需要扩容，需要扩容则在其内部扩容
    // 如果checkCapacity进行了扩容，那么 下面的elementData就是扩容后的容器
    elementData[size++] = e;
    return true;
}

/**
 * 计算最小容量
 * @param capacity 需要容量
 */
private int calcCapacity(int capacity){
    if(elementData == INITIAL_DEFAULT_CONTENT){ // 判断容器是否是空数组
        return Math.max(INIT_CAPACITY,capacity); // 比较最小容量和默认容量谁大
    }
    return capacity; // 容器不是空数组则返回最小容量
}

/**
 * 检查是否需要扩容，需要则扩容
 * @param minCapacity 最小容量
 */
private void checkCapacity(int minCapacity){
	// 最小容量是否大于数组长度，大于则需要扩容，否则跳过
    if(minCapacity - elementData.length > 0){
        expansion(minCapacity);
    }
}

/**
 * 扩容机制
 * 		扩展：>> 按位右移，不去管具体逻辑的话，可以当作是 除以 几次2 
 * 				>> 1 : 表示除以一次2
 * 				>> 2 : 除以两次2 
 * @param minCapacity 最小容量
 */
private void expansion(int minCapacity){
    int currentLength = elementData.length; // 当前数组的长度
    int newLength = currentLength + (currentLength >> 1); // 将长度进行1.5倍扩容
    // 如果扩容后的长度小于最小容量，则使用最小容量进行扩容
    if(newLength - minCapacity < 0){
        newLength = minCapacity;
    }
    // 将老数组，copy到以(扩容后的容量)的新数组中 注意(老数组的内容会copy到新数组中)
    // 创建一个newLength长度的数组，并将elementData内容放进去
    elementData = Arrays.copyOf(elementData, newLength);
}

/**
 * 查找
 * @param index
 * @return
 */
@Override
public E get(int index) {
    checkIndex(index);
    return (E) elementData[index-1];
}

/**
 * 删除某个位置的元素(注意：JDK中的remove(int index) 删除的index个下标
 * 这里删除的时下标-1个 也就是第几个元素
 * @param index
 * @return
 */
@Override
public E remove(int index) {
    checkIndex(index);

    E oldElement = (E) elementData[index-1]; // 获取要删除的元素

    // 数组长度 - 当前元素 计算出需要copy的元素
    int calcCopyLength = size - index; // 最终获取需要copy的个

    // 当index等于数组长度-1时，需要copy的元素就为0了，这个时候就不需要copy了 (例如size为9，现在删除第9个)
    if(calcCopyLength > 0){
        // 将数组中第index个开始copy，到上一个位置(index-1)，赋值calcCopyLength个
        System.arraycopy(elementData,index,elementData,index-1,calcCopyLength);
        // 假设删除第1个元素，则从第1个元素开始复制calcCopyLength个到原数组中，从第2个元素开始		复制.
    }
    elementData[--size] = null; // 删除之后最后一个位置制空

    return oldElement; // 返回被删除的元素
}

/**
 * 检查index是否在范围内
 * @param index
 */
private void checkIndex(int index){
    if(index<0 || index >= elementData.length){
        throw new RuntimeException("参数传递异常");
    }
}

@Override
public String toString() {
    return "AutoArrayList{" +
            "elementData=" + Arrays.toString(elementData) +
            '}';
}

总结：

• 为什么ArrayList增删慢，查询快
  每一次的增删都需要判断是否需要扩容，并且当删除元素时，部分元素需要重新排列。所以效率慢
• 为什么ArrayList查询快，通过索引直接定位

二、LinkedList实现

粗略的理解下双向链表

上代码

public Node first; // 首节点
public Node last; // 尾节点
public int size; // 链表长度

/**
 * 添加
 * @param e 添加的元素
 * @return
 */
@Override
public boolean add(E e) {
    linkLast(e);
    return true;
}

/**
 * 添加到末尾
 * @param e
 */
private void linkLast(E e){
	// 第一次添加，首节点和尾节点指向的都是一个元素
    // 将当前尾节点赋值给p (因为添加默认是在后面添加，所以新建的节点的上节点就是整个链表的尾节点) 第一次添加，尾节点就是null
    final Node<E> p = last;
    // 创建节点,上节点就是链表的尾节点 (因为是最后一个元素，所以下节点为null)
    final Node<E> newNode = new Node<E>(p,e,null);
    // 创建节点后，尾节点就是刚加入进来的节点了
    last = newNode;

    if(p == null){// 判断尾节点是不是null
        first = newNode; // 是说明容器没有元素，所以将首节点指向新创建的节点，
    }else{
        p.next = newNode; // 不是则说明容器中有元素，那么将当前元素的下节点指向新创建的节点
    }
    size++;
}

/**
 * 修改节点内容
 * @param index 位置
 * @param element 内容
 * @return
 */
@Override
public E set(int index, E element) {
    checkIndex(index);
    return node(index).item = element; // node()方法 根据index查询节点
}

/**
 * 根据位置查找节点内容
 * @param index
 * @return
 */
@Override
public E get(int index) {
    checkIndex(index);
    return node(index).item;
}

/**
 * 删除节点
 * @param index
 * @return
 */
@Override
public E remove(int index) {
    checkIndex(index);
    return delNode(node(index));
}

/**
 * 删除节点(实现)
 * @param node 要删除的节点
 * @return
 */
private E delNode(Node<E> node){
    /*
        注释：
            prev ==》 上节点
            node ==》 当前节点
            last ==》 尾节点
     */
    final Node<E> prev = node.prev; // 获取当前节点的上节点
    final E element = node.item;
    // 判断当前节点是否是最后一个节点
    if(node.next == null){
        last = prev; // 将尾节点指向上节点
    }else{
        prev.next = node.next; // 将上节点的下节点指向当前节点的下节点
        node.next.prev = prev; // 将当前节点的下节点的上节点指向当前节点的上节点
    }
    // 将内容制空，据说是能够帮助gc来回收垃圾
    node.prev = null;
    node.next = null;
    node.item = null;
    size--;

    return element;
}

/**
 * 位置查找节点
 * @param index
 * @return
 */
private Node<E> node(int index){
    // 二分查找
    // 例如size为10  想查找4 那么直接判断4是否小于10的一半 ，实则直接从0-4中查找，否则从4-10中查找
    if(index < (size >> 1)){
        // 查找位置在链表长度一半内
        Node<E> x = first; // 将首元素赋给x
        // 循环次数 = index - 1
        // 在没有循环之前x就已经指向的是第一个节点，循环n次，就是第n+1个节点
        for(int i = 1 ; i < index ; i++){
            x = x.next;
        }
        return x; // 遍历完直接返回
    }else{
        // 查找位置在链表长度一半外
        Node<E> x = last; // 将尾节点赋给x
        // 循环次数 = size - index
        for(int i = size ; i > index ; i--){
            x = x.prev;
        }
        return x;
    }
}

/**
 * 检查位置是否符合
 * @param index
 */
private void checkIndex(int index){
    if(index<0 || index > size){
        throw new RuntimeException("参数异常");
    }
}

/**
 * 遍历双向链表
 */
public void bianli() {
    Node first = this.first;
    while (true){
        if(first == null){
            break;
        }
        System.out.println("node == " + first.item);
        first = first.next;
    }
}

/**
 * 节点
 * @param <E>
 */
private static class Node<E>{
    Node<E> prev; // 上节点
    Node<E> next; // 下节点
    E item; // 元素

    public Node(Node<E> prev,E item,Node<E> next) {
        this.prev = prev;
        this.next = next;
        this.item = item;
    }

    @Override
    public String toString() {
        return "Node{" +
                "item=" + item +
                '}';
    }
}

本人也在学习中，目前刚刚debug一边源码，所以手动实现一下巩固一下基础。后续有机会会继续出set、map部分集合的实现。

最后感谢各位能够看到这里！