Java集合List源码解读

已于 2022-04-25 22:14:00 修改
阅读量673 收藏 3
点赞数 1
分类专栏： Java基础 文章标签： java
于 2022-04-11 00:28:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39527237/article/details/124089214
版权

Java集合List源码解读

本文也同步发表在个人网站-万隆的笔记，网站也会持续更新自己的学习笔记。

List2

概述

Java容器主要有List、Set、Map三大类，这里主要对JDK 8 的 List进行源码解读。

底层结构

List存储的元素是有序的，可重复的，List接口主要有三个实现：

  • ArrayList，底层采用的是Object[]数组，故支持随机访问，插入和删除元素时间复杂度受元素位置的影响，介于O(1)~O(n-i)之间（n为列表size、i为要操作的位置），而在内存空间占用上默认预留一定的空间。它是线程不安全的。
  • Vector，是 List 的古老实现类，底层也是使用 Object[ ]存储，与ArrayList的主要区别是它是线程安全的。
  • LinkList，底层采用的是双向链表（JDK1.6之前是循环列表，JDK1.7之后改成了双向链表），故不支持随机访问，插入和删除元素时间复杂度介于O(1)~O(n)，在内存空间占用上每个元素相比ArrayList要消耗多一点空间，因为要存放前驱、后驱信息），线程不安全。

扩容机制

除了底层数据结构，扩容机制也是面试常客。

  • 在创建ArrayList对象时，初始化的是个空数组，在第一次add方法时候，才会创建数组，默认的数据长度为10，然后如果每次add方法时候，如果最小扩容值大于数组缓冲区的长度，那么进行扩容，新容量默认扩容为旧容量的1.5倍左右
  • 在创建Vector对象时，就已经创建了数组，并不会像ArrayList那样初始化为空数组。构造函数可以指定对象数组的初始长度，此外还可以特别得指定扩容量capacityIncrement。对象数组长度也默认为10，扩容量值为0，代表每次扩容增加1倍。

ArrayList源码解读

arrayList

类的定义

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
  ......
}

ArrayList继承了AbstractList，实现了List、RandomAccess、Cloneable、Serializable接口。

  • RandomAccess：标识支持随机访问
  • Cloneable：重写了clone方法
  • Serializable：支持序列化
AbstractList

AbstractList其实是模版设计模式的应用。AbstractList类继承了AbstractCollection（Collection的模版），主要是提供了List接口的框架实现（迭代器、列表迭代器），以最大限度地减少实现由“随机访问”数据存储(如数组)支持的接口所需的工作量。对于顺序访问数据(如链表)，AbstractSequentialList也继承该类。

通常要实现一个不可修改的列表，只需要实现get(int)和size()方法：

public abstract int size(); // AbstractCollection定义了
abstract public E get(int index);

如果要实现一个可修改的列表，还必须重写set(int，E)方法

public E set(int index, E element) {
  throw new UnsupportedOperationException();
}

如果列表是可变大小的，程序员必须另外重写add(int，E)和remove(int)方法。

public void add(int index, E element) {
  throw new UnsupportedOperationException();
}
public E remove(int index) {
  throw new UnsupportedOperationException();
}

核心方法

JDK 8 中ArrayList的源码有（算是注释）1400多行，并不算多，这里只列出部分核心方法的解读（基于注释翻译，加上自己一点理解），建议通读一边，然后再看看ArrayList的扩容机制，这也是面试中可能会问到的。

部分核心方法的解读：

package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import sun.misc.SharedSecrets;

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认初始容量 ，10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 用于空实例的共享空数组实例。
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 共享空数组实例，用于默认大小的空实例。我这里称为默认空数组实例。
     * 我们将其与EMPTY_ELEMENTDATA区分开来，以便知道在添加第一个元素时膨胀多少。
     * （我第一次看到这个说明，是比较懵逼的，只知道与EMPTY_ELEMENTDATA有区别，带着疑问往下读就是啦）
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 数组缓冲区，存储数组列表中的元素。数组列表的容量是这个数组缓冲区的长度。
     * 当第一个元素被添加时，任何带有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList
     * 将被扩展为DEFAULT_CAPACITY。
     * （看到这里，大概就知道上前面的定义空数组是什么含义了，注意这里是transient修饰的）
     */
    transient Object[] elementData; // 非私有以简化嵌套类访问

    /**
     * ArrayList元素个数
     */
    private int size;

    /**
     * 可以指定初始容量的构造函数。
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            // 大于0，创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            // 等于0，直接使用了EMPTY_ELEMENTDATA共享空数组实例
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            // 其他情况 抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
     * 空参构造函数，构造一个初始容量为10的空列表。
     * （这个官方注释结合代码看起来很诧异，因为明明是将elementData指向了DEFAULTCAPACITY_EMPTY_ELEMENTDATA，
     * 初始容量明明为0，但是如果你往下看就会发现，官方的意思当添加第一个元素的时候数组容量才变成10）
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 按照集合的迭代器返回元素的顺序构造包含指定集合元素的列表
     */
    public ArrayList(Collection<? extends E> c) {
        // 集合转换为数组，注意这里c不能为null的
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            // 如果c的class是ArrayList数据类型，直接就赋值了
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                // 调用Arrays的copyOf方法，进行拷贝赋值
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // 其他情况指向为空数组
            elementData = EMPTY_ELEMENTDATA;
        }
    }

    /**
     * 将ArrayList实例的容量调整为列表的当前大小，在某些场景下这个方法有用
     */
    public void trimToSize() {
        // 这个变量来自AbstractList，记录这个列表在结构上被修改的次数
        // 主要是迭代器使用，如果发现意外更改，会抛出ConcurrentModificationException（并发不安全）
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

    /**
     * （扩容机制）指定最小容量参数，增加ArrayList实例的容量。
     * @param minCapacity 所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // 如果不是默认空数组实例，minExpand=0
            ? 0
            // 默认空数组实例，使用默认容量10 minExpand = 10
            : DEFAULT_CAPACITY;
        // 如果已经大于最小扩容值，则以指定扩容值为准
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

    /** 
    * 计算容量，返回的最小扩容量，后面扩容会使用
    */
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // elementData是默认空数组实例，返回DEFAULT_CAPACITY与minCapacity最大的值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 否则直接返回minCapacity
        return minCapacity;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    /**
    * 判读是否需要扩容扩容！！！
    */
    private void ensureExplicitCapacity(int minCapacity) {
        // 这里上面有说，不赘述。扩容可定会可能修改结构
        modCount++;

        // 扩容代码！！，如果最小扩容值大于数组缓冲区的长度，进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * 能分配数组的最大值，-8是因为某些虚拟机会在数组头保留一些信息
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * （扩容核心方法）增加容量，以确保它至少可以容纳最小容量参数指定的元素数量。
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量
        int oldCapacity = elementData.length;
        // newCapacity为新容量，默认为旧容量的1.5倍左右（官方默认扩展1.5倍左右就够了）
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 检查新容量与最小容量参数，若新容量小于最小容量参数，那么就把最小容量参数当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 检查新容量与最大容量值，若新容量超出了最大容量值，则调用hugeCapacity()来比较minCapacity和MAX_ARRAY_SIZE（见方法）
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity通常接近大小，意思就是newCapacity很有可能是等于minCapacity
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
  
    // ......

    /**
     * 判断列表是否包含指定的元素，底层调用了indexOf
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 返回此列表中指定元素的首次出现的索引，如果不包含返回-1
     */
    public int indexOf(Object o) {
        // 这里官方针对null直接开辟了一个分支去循环，
        // 可以借鉴，后面很多都是这种写法， lastIndexOf是倒序遍历
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
  
    // ......

    /**
     * 返回ArrayList实例的浅拷贝
     */
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

    /**
     * 返回一个数组，该数组以正确的顺序(从第一个元素到最后一个元素)包含该列表中的所有元素。
     * 返回的数组将是“安全的”，因为这个列表不维护对它的引用。
     * (换句话说，这个方法必须分配一个新数组)。因此，调用者可以自由地修改返回的数组。
     * 此方法充当了基于数组和基于集合的api之间的桥梁。
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    // ......

    /**
     * 返回列表中指定位置的元素。
     */
    public E get(int index) {
        // 范围检查
        rangeCheck(index);

        return elementData(index);
    }

    /**
     * 将此列表中指定位置的元素替换为指定的元素。
     * 返回旧元素
     */
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    /**
     * 将指定的元素追加到此列表的末尾。
     */
    public boolean add(E e) {
        // 确保内部容量（判断以及扩容）
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 实质上就是数组赋值
        elementData[size++] = e;
        return true;
    }

    /**
     * 将指定的元素插入到此列表中的指定位置。
     * 将当前位置的元素(如果有的话)和随后的元素向右移动(给它们的下标加1)。
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        // 确保内部容量（判断以及扩容）
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 将index以及随后的元素向右移动
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    /**
     * 移除该列表中指定位置的元素。将后面的所有元素向左移动(从它们的下标中减去1)
     * 返回移除的值
     */
    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

    /**
     * 如果指定元素存在，则从该列表中删除该元素的第一个匹配项。如果列表中不包含该元素，则该元素不变。
     */
     public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    /*
     * 跳过边界检查且不返回已删除值的私有remove方法。
     */
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 删除元素，意味着要移动元素
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

    /**
     * 从列表中移除所有元素，元素置为空
     */
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

    /**
     * 将指定集合中的所有元素按照指定集合的迭代器返回的顺序追加到该列表的末尾。
     */
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        // 扩容
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
     * 将指定集合中的所有元素从指定位置开始插入到此列表中。
     * 将当前位置的元素(如果有的话)和随后的元素向右移动(增加它们的索引)。
     * 新元素将按照指定集合的迭代器返回的顺序出现在列表中。
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        // 扩容
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
     * 从列表中删除所有索引位于fromIndex(包含的)和toIndex(排除的)之间的元素。
     * 续的所有元素向左移动(减少其索引)。
     * 这个调用通过(toIndex - fromIndex)元素缩短列表。(如果toIndex==fromIndex，此操作无效。)
     */
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

    /**
     * 检查给定的索引是否在范围内。
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    // ......

    /**
     * 从该列表中移除指定集合中包含的所有元素。
     */
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

    /**
     * 仅保留列表中包含在指定集合中的元素。换句话说，从该列表中删除指定集合中不包含的所有元素。
     */
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

    // ......

   

    /**
     * 返回在指定的fromIndex(包含的)和toIndex(排除的)之间的列表部分的视图。(如果fromIndex和toIndex相等，返回的列表为空。)
     * 返回的列表由该列表支持，因此返回列表中的非结构性更改反映在该列表中，反之亦然。返回的列表支持所有可选的列表操作。
     * 该方法消除了显式范围操作的需要(数组通常存在的排序)。任何需要列表的操作都可以通过传递子列表视图而不是整个列表来用作范
     * 围操作。例如，下面的习惯用法从列表中删除了一系列元素: list.subList(from, to).clear();
     */
    public List<E> subList(int fromIndex, int toIndex) {
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }

    static void subListRangeCheck(int fromIndex, int toIndex, int size) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > size)
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                               ") > toIndex(" + toIndex + ")");
    }

    private class SubList extends AbstractList<E> implements RandomAccess {
      // ......
    }

		/**
		* 排序
		*/
    @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }
}

扩容机制（重点）

如果你通读了上面的源码，你就会注意到：在所有的addXxx的方法中都会调用到ensureCapacityInternal这个方法，没错！这个方法可以说就是ArrayList的扩容机制的核心！

我们以通常使用的过程，创建ArrayList对象、调用add方法来解析ArrayList的扩容机制。

构造函数

创建ArrayList对象有三种方式：

/**
* 默认初始容量 ，10
*/
private static final int DEFAULT_CAPACITY = 10;

/**
* 用于空实例的共享空数组实例。
*/
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
* 共享空数组实例，用于默认大小的空实例。我这里称为默认空数组实例。
* 与EMPTY_ELEMENTDATA区分开来，以便知道在添加第一个元素时膨胀多少。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
* 可以指定初始容量的构造函数。
*/
public ArrayList(int initialCapacity) {
  if (initialCapacity > 0) {
    // 大于0，创建initialCapacity大小的数组
    this.elementData = new Object[initialCapacity];
  } else if (initialCapacity == 0) {
    // 等于0，直接使用了EMPTY_ELEMENTDATA共享空数组实例
    this.elementData = EMPTY_ELEMENTDATA;
  } else {
    // 其他情况 抛出异常
    throw new IllegalArgumentException("Illegal Capacity: "+
                                       initialCapacity);
  }
}

/**
* 空参构造函数，构造一个初始容量为10的空列表。
* （这个官方注释结合代码看起来很诧异，因为明明是将elementData指向了DEFAULTCAPACITY_EMPTY_ELEMENTDATA，
* 初始容量明明为0，但是如果你往下看就会发现，官方的意思当添加第一个元素的时候数组容量才变成10）
*/
public ArrayList() {
  this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
* 按照集合的迭代器返回元素的顺序构造包含指定集合元素的列表
*/
public ArrayList(Collection<? extends E> c) {
  // 集合转换为数组，注意这里c不能为null的
  Object[] a = c.toArray();
  if ((size = a.length) != 0) {
    // 如果c的class是ArrayList数据类型，直接就赋值了
    if (c.getClass() == ArrayList.class) {
      elementData = a;
    } else {
      // 调用Arrays的copyOf方法，进行拷贝赋值
      elementData = Arrays.copyOf(a, size, Object[].class);
    }
  } else {
    // 其他情况指向为空数组
    elementData = EMPTY_ELEMENTDATA;
  }
}
  • 指定初始化容量的构造函数：如果指定的容量initialCapacity>0，那么按照initialCapacity的大小创建数组；如果initialCapacity==0，初始化的是EMPTY_ELEMENTDATA，也是个空数组；其他情况会抛出异常。
  • 无参数构造函数：初始化的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，是一个空数组。
  • 集合参数的构造函数：主要根据集合c的数据类型而定，如果是ArrayList数据类型，直接就引用赋值了，否则就会调用Arrays.copyOf进行拷贝赋值，而其他情况呢就会指向EMPTY_ELEMENTDATA，前面说了是个空数组。

到这里，需要注意指定初始化容量的构造函数初始化结果是个空数组，并不是我们想的那样马上就分配内存！

还有你可能疑惑了，无参数构造函数为什么搞特殊，要指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA，而不是像其他构造函数一样指向EMPTY_ELEMENTDATA，而且DEFAULT_CAPACITY=10，也没有见构造函数用到啊？

先说答案：DEFAULTCAPACITY_EMPTY_ELEMENTDATA是为了区别于EMPTY_ELEMENTDATA，当向数组中添加第一个元素时，数组容量才会扩扩为 10。

添加元素

添加元素的方法有很多 add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)等等，每个方法内部都无一例外的调用了ensureCapacityInternal()方法：

/**
* 将指定的元素追加到此列表的末尾。
*/
public boolean add(E e) {
  // 确保内部容量（判断以及扩容）
  ensureCapacityInternal(size + 1);  // Increments modCount!!
  // 实质上就是数组赋值
  elementData[size++] = e;
  return true;
}

那么ensureCapacityInternal()方法到底干了什么？

ensureCapacityInternal()方法

ensureCapacityInternal()相关源码调用逻辑如下：

private void ensureCapacityInternal(int minCapacity) {
  ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

/** 
* 计算容量，返回的最小扩容量，后面扩容会使用
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
  // elementData是默认空数组实例，返回DEFAULT_CAPACITY与minCapacity最大的值
  if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    return Math.max(DEFAULT_CAPACITY, minCapacity);
  }
  // 否则直接返回minCapacity
  return minCapacity;
}

/**
* 判读是否需要扩容！！！
*/
private void ensureExplicitCapacity(int minCapacity) {
  modCount++;

  // 扩容代码！！，如果最小扩容值大于数组缓冲区的长度，进行扩容
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}

从上面源码可以看得出来，ensureCapacityInternal()就个套娃，先后调用了calculateCapacity()和ensureExplicitCapacity()方法：

  • calculateCapacity()： 这个方法目的是返回最小扩容量，这里就是包含了前面说的情况，一般来说，add第1个元素minCapacity=1，而elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA又成立，那么 Math.max(DEFAULT_CAPACITY, minCapacity)肯定是10。
  • ensureExplicitCapacity()：这个方法目的是判断是否需要扩容，如果最小扩容值大于数组缓冲区的长度，会调用grow()方法进行扩容。例如，上面说的minCapacity=10，此时elementData.length=0，那么最后会调用grow(10);

我们可以梳理一下，模拟调用程序执行过程：

  1. 使用空参构造函数，elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; 并且elementData.length为0
  2. add 第 1 个元素到 arrayList 对象时，调用ensureCapacityInternal(0 + 1)，接着执行 calculateCapacity(1) 方法后返回的minCapacity为 10。而后又调用ensureExplicitCapacity(minCapacity)，此时，minCapacity - elementData.length > 0成立，所以，会调用grow(minCapacity) 方法。
  3. 接着，当我们 add 第 2 个元素时，重复第2步的过程，会得到minCapacity 为 1 + 1 = 2，此时elementData.length在添加第一个元素后已经扩容成 10 了。此时，minCapacity - elementData.length> 0 不成立，所以不会调用grow(minCapacity) 方法。
  4. 一直添加第 3、4···到第 10 个元素时，依然不会执行 grow 方法，数组容量都为 10。直到添加到第11个元素，minCapacity - elementData.length> 0 才会成立，再次进行扩容！
grow()方法

grow()方法的源码如下：

/**
* 能分配数组的最大值，-8是因为某些虚拟机会在数组头保留一些信息
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
* （扩容核心方法）增加容量，以确保它至少可以容纳最小容量参数指定的元素数量。
*/
private void grow(int minCapacity) {
  // oldCapacity为旧容量
  int oldCapacity = elementData.length;
  // newCapacity为新容量，默认为旧容量的1.5倍左右（官方默认扩展1.5倍左右就够了）
  int newCapacity = oldCapacity + (oldCapacity >> 1);
  // 检查新容量与最小容量参数，若新容量小于最小容量参数，那么就把最小容量参数当作数组的新容量，
  if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;
  // 检查新容量与最大容量值，若新容量超出了最大容量值，则调用hugeCapacity()来比较minCapacity和MAX_ARRAY_SIZE（见方法）
  if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);
  // minCapacity通常接近大小，意思就是newCapacity很有可能是等于minCapacity
  elementData = Arrays.copyOf(elementData, newCapacity);
}

其实grow()方法的并不复杂，核心代码是int newCapacity = oldCapacity + (oldCapacity >> 1);，即ArrayList每次扩容的新容量默认为旧容量的1.5倍左右，后面就是对这个默认的扩容量与minCapacity、MAX_ARRAY_SIZE进行一些比较判断取值，最后，将得到的扩容值使用Arrays.copyOf进行扩容。

  • 如果newCapacity值（默认扩容1.5）比minCapacity小，那就以minCapacity为扩容量，以大的为准。

  • 如果newCapacity值比MAX_ARRAY_SIZE要大，那就需要经过hugeCapacity(minCapacity)计算，源代码如下

    private static int hugeCapacity(int minCapacity) {
  if (minCapacity < 0) // overflow
    throw new OutOfMemoryError();
  return (minCapacity > MAX_ARRAY_SIZE) ?
    Integer.MAX_VALUE :
  MAX_ARRAY_SIZE;
}

再以我们刚才的例子为例，模拟调用程序执行过程

  1. 当 add 第 1 个元素时，调用grow函数，minCapacity=10。此时，oldCapacity为0，newCapacity计算当然也为0；经第一个 if 判断成立，newCapacity = minCapacity，也就是10。但是第二个 if 判断不会成立，即 newCapacity（10） 明显不大于MAX_ARRAY_SIZE ，则不会进入 hugeCapacity() 方法。扩容结果：数组容量扩为 10，add 方法 return true，size 增为 1。
  2. 在add到第11个元素前，都不会调用grow函数。
  3. 当 add 第 11 个元素时，调用grow函数，minCapacity=11。此时，oldCapacity为10，newCapacity计算为 15；newCapacity（15）比 minCapacity（为 11）大，第一个 if 判断不成立。显然，也不会大于MAX_ARRAY_SIZE，不会进入 hugeCapacity() 方法。扩容结果：数组容量扩为 15，add 方法 return true，size 增为 11。
  4. 以此类推，······
总结
  • 在使用ArrayList默认构造函数创建对象时，是个空数组。
  • 在添加第一个元素时，默认初始化长度为10数组。
  • 在每次进行添加元素操作时候，arrayList都会用最小扩容值与数组长度进行比较（minCapacity > elementData.length），判断是否需要扩容（grow()），如果需要扩容，则默认情况下每次扩容的新容量默认为旧容量的1.5倍左右。

Vector源码解读

Vector

类的定义

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    ......
}

Vector的类定义是不是很眼熟，是的！它的继承以及接口的实现与ArrayList一致。这里我就不赘述了，

核心方法&扩容机制

前面说过，Vector与ArrayList最大区别就是线程安全，所以关于源码，基本ArrayList上与差不多，只是很多方法加了synchronized修饰，保证线程安全。此外，扩容方法与像ArrayList也类似，所以关于源码不会像ArrayList那样整篇贴出来了，这里会列出部分方法。

构造函数
/**
* 存放元素的对象数组
*/
protected Object[] elementData;

/**
* 存放的有效元素个数
*/
protected int elementCount;

/**
* 当新增元素数量大于其容量时，其容量自动增加的量。
* 如果容量增量小于或等于零，则每次需要增长时，容量都会增加一倍。
*/
protected int capacityIncrement;

/**
* 与ArrayList区别，除了可以指定初始化容量，还可以指定扩容时增加的量
*/
public Vector(int initialCapacity, int capacityIncrement) {
  super();
  if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal Capacity: "+
                                       initialCapacity);
  this.elementData = new Object[initialCapacity];
  this.capacityIncrement = capacityIncrement;
}

/**
* 仅指定初始化容量，扩容量默认为0.
* 扩容量为0，表示每次需要增长时，容量都会增加一倍
*/
public Vector(int initialCapacity) {
  this(initialCapacity, 0);
}

/**
* 空构造函数，默认初始化容量为10，扩容量为0（每次扩容增加一倍）
*/
public Vector() {
  this(10);
}

/**
* 这一块与ArrayList，差不多
*/
public Vector(Collection<? extends E> c) {
  Object[] a = c.toArray();
  elementCount = a.length;
  if (c.getClass() == ArrayList.class) {
    elementData = a;
  } else {
    elementData = Arrays.copyOf(a, elementCount, Object[].class);
  }
}

从构造函数上看，对比ArrayList有一下区别：

  • 创建Vector对象的时候，就已经创建了数组，并不会像ArrayList那样初始化为空数组。
  • 默认初始化数组长度为10，每次扩容增加一倍
  • 可以指定扩容量capacityIncrement，如果小于或等于0表示每次扩容增加一倍。
扩容机制

Vector扩容机制与ArrayList基本相似，从add方法看起

/**
* add方法加了synchronized，线程安全
* 扩容调用了ensureCapacityHelper
*/
public synchronized boolean add(E e) {
  modCount++;
  ensureCapacityHelper(elementCount + 1);
  elementData[elementCount++] = e;
  return true;
}

/**
* 除了名字外，逻辑基本与ArrayList相同
*/
private void ensureCapacityHelper(int minCapacity) {
  // 注意到没有，这里比ArrayList少了一行代码（modCount++）因为它是线程安全的
  // overflow-conscious code
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}

private void grow(int minCapacity) {
  // overflow-conscious code
  int oldCapacity = elementData.length;
  // 差别在默认扩容，判断capacityIncrement的值，
  //   如果大于0，以创建对象时定义的扩容量为准，否则扩容量为旧容量的一倍
  int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                   capacityIncrement : oldCapacity);
  if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;
  if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);
  elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
  if (minCapacity < 0) // overflow
    throw new OutOfMemoryError();
  return (minCapacity > MAX_ARRAY_SIZE) ?
    Integer.MAX_VALUE :
  MAX_ARRAY_SIZE;
}

分析源代码，可以看得出来，在没有指定扩容量的情况下，Vector的默认扩容量为原来的一倍。

总结
  • 创建Vector对象时，可以指定对象数组的初始长度，此外还可以特别得指定扩容量`capacityIncrement。
  • 默认情况下，对象数组长度默认为10，扩容量值为0，代表每次扩容增加一倍。
  • 与ArrayList主要的不同：线程安全，创建对象时没有空数组概念以及每次扩容默认增加一倍。

LinkedList源码解读

LinkedList.png

关于List的源码马上就差不多读完了，坚持一下，这一节很快就过去。

类的定义

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
    ......
}

LinkedList类的继承与实现接口体系与ArrayList、Vector有些许不同，继承了AbstractSequentialList，而不是AbstractList（其实间接继承了，看图），实现了Deque接口。

  • AbstractSequentialList抽象类：官方封装的对于顺序访问数据(比如一个链表)实现List的一个模版类
  • Deque接口：继承了Queue接口，支持两端元素插入和删除的线性集合。deque这个名字是“双端队列”的缩写，通常读作“deck”。大多数Deque实现对它们可能包含的元素数量没有固定的限制，但是这个接口支持容量限制的Deque以及没有固定大小限制的Deque。

其实根本原因是，LinkedList使用的底层数据结构与ArraysList、Vector不同，它使用的是双向链表（JDK1.6之前是循环列表，JDK1.7之后改成了双向链表），而AbstractSequentialList、Deque则是封装了链表的一些操作以及特性。

底层数据结构

在LinkedList里有个私有的静态Node类，它就是双向链表每个节点的定义：

private static class Node<E> {
  // 元素
  E item;
  // 后驱节点
  Node<E> next;
  // 前驱节点
  Node<E> prev;

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

关于双向链表的特性以及操作方法，这里不进行讲述了，有兴趣的可以自行查阅相关资料。

核心方法

构造函数
// 链表的大小
transient int size = 0;
// 指向第一个节点的指针。
transient Node<E> first;
// 指向最后一个节点的指针。
transient Node<E> last;

/**
* 构造一个空的链表
*/
public LinkedList() {
}

/**
* 按照集合的迭代器返回元素的顺序构造包含指定集合元素的列表。
*/
public LinkedList(Collection<? extends E> c) {
  this();
  addAll(c);
}

可以看的出来，LinkedList的构造函数非常简单，没有像ArrayList、Vector那样的可以指定容量或扩容值的构造函数，毕竟使用的是双向链表，没有扩容的说法，例如添加方法，每次添加元素只需要找到指定的位置，维护前后节点的信息即可：

add方法
/**
* 将指定的元素追加到此列表的末尾。这个方法相当于addLast。
*/
public boolean add(E e) {
  linkLast(e);
  return true;
}


/**
* 在尾节点追加元素e
*/
void linkLast(E e) {
  final Node<E> l = last;
  final Node<E> newNode = new Node<>(l, e, null);
  last = newNode;
  if (l == null)
    first = newNode;
  else
    l.next = newNode;
  size++;
  modCount++;
}

至于，其他的方法这里就不再细说了，如果对双向链表所有了解，一切都会变得非常简单。

万隆同学
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值