ArraryList和Vector源码，白话讲解，手把手操作（第一版）

Burfitt.Lee

已于 2022-04-10 12:09:45 修改

阅读量80

点赞数 1

文章标签： java 数据结构 list

于 2022-04-09 23:33:43 首次发布

本文链接：https://blog.csdn.net/weixin_48045037/article/details/124069424

版权

ArraryList源码

说到ArrayList最需要了解的三点就是初始化、扩容、线程安全
因为疫情，刚好周六，想着阿里巴巴规范建议实例化集合时指定初始化大小，干脆整理一版文章也加深下自己的印象吧，请一定静下心打开IDEA，拿出至少半个小时跟着我一步步点下来，一两遍就熟悉了
我们今天主要就ArrayList和Vector来简单区分两者的区别，考虑到可能有初学者进到方法可能都不会(经历过)，避免看的云里雾里，就每一个步骤写的比较详细，适合小白，大佬勿喷，仅供参考，第一版因为时间问题会比较粗糙，会逐步优化内容为简洁易懂的。
需要了解:
ArrayList 非线程安全的List集合
Vectgor 线程安全的List集合

初始化

ArrayList

初始化在扩容到jdk1.8后和Vector初始化的方式分道扬镳了
ArrayList现在主要是在add时使用了一个常量

/**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

首先我们看一下ArrayList的无参构造器

List<String> listStr = new ArrayList<>();
listStr.add("aaa");
listStr.add("bbb");
listStr.add("cccc");

我们把鼠标放到ArrayList按住ctrl+鼠标左键进到ArrayList查看到其无参构造器


    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

看到这段代码后ctrl+鼠标左键查看DEFAULTCAPACITY_EMPTY_ELEMENTDATA

   /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

现在我们发现这是一个空数组，可能有点困惑，不是应该实例化的时候有默认初始化10嘛;

因为在jdk1.8 开始 ArrayList不再是实例化时直接初始化大小了，而是改成了add时初始化，其中的具体改动我们稍后在Vector对比

我们继续刚才的步骤，现在Arrayist已经属于实例化完成，我们可以查看添加的源码了

在liststr.add(“aaa”); 将鼠标悬停在add上 ctrl+右键进入方法，在实现类中找到ArrayList.add（当然如果你理解的话，可以直接在ArrayList中ctrl+f在页面搜索add直接找到重写后的方法）
在这里插入图片描述此时你应该能见到如下代码

   /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

参数e 即你要传如的数据，关于这个size 是设置了一个没赋值的变量，默认0 ，因为你这里调用add 算是要添加一个了，所以size要+1
注意此时开始的代码就是关键代码了
进入方法ensureCapacityInternal

 private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

if中的意思是 elementData(当前元素个数) == 当前的容量时 Math.max 返回参数1(常量10)和参数2(刚才传入的size+1=1)比较的结果最大值
把值带入到代码的话如下

private void ensureCapacityInternal(int 1) { //传递时size+1=1
        if (0(当前列表数量)== 0(最开始初始化时的空数组)) {
            // 返回的结果为10
            minCapacity = Math.max(10(常量), 1(传入的参数));
        }

        ensureExplicitCapacity(10);
    }

这样替换完是不是瞬间看懂了，我们继续看下面的ensureExplicitCapacity(10)


    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

马上进入核心扩容方法啦，我们看下这个if的判断条件
如果传递的参数 - 当前集合长度 > 0 则扩容
替换为 10 - 0 > 0 = true 需要扩容，这里包括后面添加的也是按照这个条件来判断扩容。
接着进入方法grow(minCapacity);最核心的扩容方法

    /**
     * 顶部有一个常量是 要分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        // 将oldCapacity 右移一位  我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍
        // 扩容公式：新容量 = 旧容量/2 + 旧容量（底层是通过移位操作，右移一位相当于除以2，左移一位相当于乘以2）
        // 此时替换结果为 0 = 0+(0/2=0)  newCapacity是0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
         // 然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量
         // 替换为 0-10<0 =true
         // 最后将newCapacity赋值了我们传递进来的10  完成初始化大小的赋值
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
       // 如果minCapacity大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 进行拷贝扩容操作，参数1是原数组，参数2是新大小 将会返回一个新数组，
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

Vector

了解完ArrayList的初始化是在add时才定的，我们看下Vector的初始化

    Vector<String> vector = new Vector<>();
    vector.add("测试");
    vector.add("xxxx");

进入Vector的无参构造方法

  /**
     * Constructs an empty vector so that its internal data array
     * has size {@code 10} and its standard capacity increment is
     * zero.
     */
    public Vector() {
        this(10);
    }

ctrl+右键进入this(10)，这里的10就是指定了初始化大小

  /**
     * Constructs an empty vector with the specified initial capacity and
     * capacity increment.
     *
     * @param   initialCapacity     the initial capacity of the vector
     * @param   capacityIncrement   the amount by which the capacity is
     *                              increased when the vector overflows
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

此时 this.elementData = new Object[initialCapacity];即创建了一个数组大小为10的大小。

在Vector我们需要注意的是线程安全，我之前面试有被问到，可以看到在初始化中并没有关于同步方法以及锁的设定，所以盲猜一定在add中有所添加
查看Vector的add方法

  /**
     * Appends the specified element to the end of this Vector.
     *
     * @param e element to be appended to this Vector
     * @return {@code true} (as specified by {@link Collection#add})
     * @since 1.2
     */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

可以看到有synchronized 所以在添加时是线程安全的

初始化总结:

ArraryList的初始化是add时进行，Vector则仍采用实例化时直接初始化大小
二者皆可直接指定大小，均提供了对应的构造方法
优缺点对比，ArraryList采用的新初始化方式节省了开销，Vector实际上是创建了两个对象。
ArrayList和Vactor都是允许自己设置初始容量的，调用带参数的构造方法即可，然后以这个初始容量按照1.5倍当前设置的初始容量进行扩容。