集合【源码分析】--- ArrayList

阿琛c

已于 2022-08-20 12:31:19 修改

阅读量205

点赞数

分类专栏： Java语法学习文章标签： java 数据结构

于 2022-08-20 12:23:29 首次发布

本文链接：https://blog.csdn.net/weixin_49199821/article/details/126438114

版权

Java语法学习专栏收录该内容

12 篇文章 6 订阅

订阅专栏

ArrayList源码分析

ArrayList与源码分析
ArrayList类中有几个非常重要的成员变量（DEFAULT_CAPACITY、EMPTY_ELEMENTDATA、DEFAULTCAPACITY_EMPTY_ELEMENTDATA、elementData）。此外还有成员变量size,它用来表示当前集合的数据容量。
在这里插入图片描述

再看类的构造方法

 public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
 
   
调用无参数构造方法时将储存数据的Object[]elementData赋值为空数组
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
 
   
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

由以上源码可知。我们经常调用new ArrayList<>()无参数构造方法来创建对象时，在构造方法内部默认设置的是一个空数组，因此底层数组长度为0；值得注意的是这是jdk1.8的特性，在1.7中底层数组长度为10；我们还注意到调用有参构造方法public ArrayList(int initialCapacity)可以初始化一个initialCapacity容量大小的elementData数组。下面我们以构造方法public ArrayList(int initialCapacity)中形参initialCapacity变量为切入点的来探究一下ArrayList类

探究一:initialCapacity？成员变量size？ArrayList中元素个数？ArrayList当前容量？还在傻傻分不清？

如果你不知道这个问题描述的是什么，那么请看下面一个简单的测试

public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList<>(10);
        int index=9;
        int data=9;
        arrayList.add(index,data);
    }

上面的代码，我们调用有参构造方法初始化一个容量为10的ArrayList,那么用于存储数据的elementData数组就是一个容量为10的数组，然后我们在索引为9的位置存储值为9的元素，值9似乎自然而然能存储在elementData数组索引为9的位置，但是我们看一下控制台

在这里插入图片描述

根据这个异常错误信息，往下标9的位置插入数据超越了数组的界限。这就很奇怪了，明明我们ArrayList的initalCapacity是10，为什么下标9会越界呢？

我们根据控制台错误信息点击进入ArrayList类中的add方法、rangeCheckForAdd方法

public void add(int index, E element) {
        rangeCheckForAdd(index);
 
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

从代码中可以看出，异常信息就是从rangeCheckForAdd方法中抛出来的，原来ArrayList是使用size属性来确定数组是否越界，并非构造方法public ArrayList(int initialCapacity)中的initialCapacity。

让我们再来看看add(E e)函数的源代码：

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e; // 在末尾插入数据之后，size++
    return true;
}

可以看到，add(E e)函数会在数组的末尾插入数据，并进行size++的操作。

也就是说，只有当插入新数据的时候，size才会往上提升。

同样的，如果我们检查 remove(int index) 的源代码，也会发现它会进行size–的操作。

因此，size表示的是数组中元素的数量，并非数组的容量。
在这里插入图片描述

这一点从ArrayList类中对elementDa、size这两个成员变量的注释有中也可以看出：

ArrayList的容量是elementData数组的长度，ArrayList中包含的元素的个数是size的大小

在检查了ArrayList的源代码之后，我们可以总结出以下结论：

在ArrayList中，size与initialCapacity是不同的概念
size指的是ArrayList中元素的数量
initialCapacity指的是在ArrayList底层实现中Object数组的大小，也可以理解为ArrayList的容量
ArrayList是使用size来判断数组是否越界

在之前我们为了引出问题，实质上错误地使用了add(int index, E element)方法。要想不触发IndexOutOfBoundsException异常，由上面的源码可以看出，得保证0<=index<=size.也就是说索引值必须为正数并且在ArrayList中已经包含的元素个数的范围之内。如下图所示，假设我们调用有参数构造方法ArrayList arrayList=new ArrayList<>(7)，将elementData[]数组容量初始化为7。并且调用add()方法依次在索引 0、1、2、3的位置添加数据 3、2、7、9。我们接下来再调用

add(int index, E element)方法，正确的索引应该是 0~3,而插入索引值为 4、5、6的位置都会触发IndexOutOfBoundsException异常
在这里插入图片描述

利用有参数构造方法public ArrayList(int initialCapacity) 来初始化一个ArrayList，这正是阿里巴巴Java开发手册中所建议的，原话是：集合初始化时，指定集合初始值大小。

探究二:jdk1.8下的ArrayList扩容机制?

首先，网上有关“ArrayList扩容机制”的文章很多，众说纷坛，我用的jdk的详细版本是jdk1.8.0_191。本文所展示的源码也是出自jdk1.8.0_191。

我们知道ArrayList有下面三种构造方法：

使用每一种构造方法创建ArrayList实例之后，ArrayList初试容量以及扩容机制的具体行为都是不一样的。

 public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
 
   
调用无参数构造方法时将储存数据的Object[]elementData赋值为空数组
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
 
   
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

下面我们来逐一探讨一下：

1.使用无参数构造方法public ArrayList()创建实例后，ArrayList初试容量以及扩容机制的具体行为。

首先明确，使用无参数构造方法创建ArrayList实例之后，Object[] elementData为空数组；

elementData.length=0;ArrayList成员变量size=0

我们看一下源码：

 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
 private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
 
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
 
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
 
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

下面我们自己写一个简单的示例，并打开dubug模式跟踪一下源码

在这里插入图片描述

首先我们进入add(E e)方法，该方法首先调用ensureCapacityInternal(size+1),由于size=0，故该方法传入的形参为1

在这里插入图片描述

然后我们进入ensureCapacityInternal方法，发现该方法中调用了ensureExplicitCapacity方法，而ensureExplicitCapacity方法的形参是calculateCapacity函数的返回值

在这里插入图片描述

我们现在需要计算出calculateCapacity函数的返回值。由于调用无参数构造方法时将储存数据的Object[]elementData赋值为空数组，那么自然而然进入calculateCapacity函数中的if语句。DEFAULT_CAPACITY=10，minCapacity=1 。故calculateCapacity函数的返回值为10。
在这里插入图片描述

calculateCapacity函数的返回值拿到以后，传入到ensureExplicitCapacity函数中，并且该函数中minCapacity=10，而elementData目前为空数组，故elementData.length=0.

该函数中if条件成立，执行grow函数
在这里插入图片描述

在grow函数中

int oldCapacity = elementData.length 执行后oldCapacity=0

int newCapacity = oldCapacity + (oldCapacity >> 1)执行后newCapacity=0

minCapacity=10，if语句条件成立

if (newCapacity - minCapacity < 0){ newCapacity = minCapacity;}执行后newCapacity=10

然后执行elementData = Arrays.copyOf(elementData, newCapacity)将elementData由原来的空数组变成容量为10的数组

在这里插入图片描述

至此add方法中的ensureCapacityInternal执行完毕，接下来执行elementData[size++] = e 将值1加入集合并将size+1

此后，我们再向ArrayList中添加2、3、4、5、6、7、8、9、10。跟踪源码发现，
在这里插入图片描述

添加2、3、4、5、6、7、8、9、10的过程中不再执行grow扩容函数

在这里插入图片描述

但是当我们执行arrayList(11)时，即向集合中添加第11个元素的时候，gorw函数再次执行了

在这里插入图片描述

这次int newCapacity = oldCapacity + (oldCapacity >> 1)执行后newCapacity=15

再经过elementData = Arrays.copyOf(elementData, newCapacity)，elementData拓展为容量15的数组。

关于一个整形变量右移一位，num>>1，如果num为正偶数，那么num>>1等价于num/2。

如果num为正奇数，那么num>>1等价于num/2向下取整。所以ArrayLis容量不足时，扩容50%或者扩容到原来的1.5倍的说法并不严谨
在这里插入图片描述

但是就这样一直1.5倍地增加，难道就没有上限？其实不然，我们仔细看一下grow函数中的第二个if语句的条件。首先我们明确常量MAX_ARRAY_SIZE的值

在这里插入图片描述

当newCapacity(也即size+size>>1)大于MAX_ARRAY_SIZE时，会触发hugeCapacity函数。如果

=size+1 > ，那么就扩容到;如果size+1<= 就扩容到;

如果size+1>

则会抛出OutOfMemoryError错误

2.使用有参数构造方法public ArrayList(initialCapacity)创建实例后，ArrayList初试容量以及扩容机制的具体行为。

首先我们明确调用有参构造方法以后，elementData不再是一个空数组，而是一个容量为initialCapacity的数组

下面我们再来看一个简单的例子：
在这里插入图片描述

在这个例子中，我们初始化elementData数组容量为5.然后依次在集合中添加12个数据。跟前面的方法类似，利用debug 调试模式跟踪源码发现。在集合中添加initialCapacity+1个元素之前，ArrayList均不发生扩容行为，添加initialCapacity+1个时，扩容50%。之后依次类推，容量不够时调用grow函数扩容50%。依次类推，最后由hugeCapacity函数确定扩容上限或抛出错误

3.使用有参数构造方法public ArrayList(Collection<? extends E> c)创建实例后，ArrayList初始容量以及扩容机制的具体行为。

首先看看构造方法：

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

首先参数构造方法public ArrayList(Collection<? extends E> c)创建实例后，elementData是空数组还是装载了一定数量元素的数组，取决于传入的集合，若传入集合为空，那么elementData还是空数组，集合的初始容量为0。如果传入集合中有n个元素，那么新创建的ArrayList实例的初始容量也为n,之后再向ArrayList中添加元素就会触发扩容函数，以50%扩展容量。依次类推，最后由hugeCapacity函数确定扩容上限或抛出错误。

下面我们来总结一下使用无参数构造方法创建ArrarList实例后，ArrayList内部的扩容行为

在这里插入图片描述

前面我们是调用add方法来分析具体的扩容行为，在addAll()方法中呢？扩容机制有没有变化？先看addAll方法

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;
    }

ArrayList中提供了一个内部类Itr，实现了Iterator接口，采用内部类可以访问成员变量elementData数组，实现对集合元素的遍历

 public Iterator<E> iterator() {
        return new Itr();
    }
 
    /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
 
        Itr() {}
 
        public boolean hasNext() {
            return cursor != size;
        }
 
        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

探究三:为什么ArrayList是线程不安全的？

此外，ArrayList是线程不安全的。首先说一下什么是线程不安全：线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。 List接口下面有两个实现，一个是ArrayList，另外一个是vector。从源码的角度来看，因为Vector的方法前加了，synchronized 关键字，也就是同步的意思，因此Vector是线程安全的，而arraylist类中的方法没有加锁虽然线程不安全但是多线程访问该类效率明显高于Vector。以向集合中添加元素为例,首先看一下ArrayList与Vector类中的add（）方法源码

//arrayList类add方法源码
 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
//Vector类add方法源码
public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

一个 ArrayList ，在添加一个元素的时候，它可能会有两步来完成：

在elementData[size]数组位置添加元素
size++数组容量加1
在单线程运行的情况下，如果 size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；
而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意，我们假设的是添加一个元素是要两个步骤，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值。那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于 2。这就是“线程不安全”了。

阿琛c

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合【源码分析】--- ArrayList

首先说一下什么是线程不安全：线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。从源码的角度来看，因为Vector的方法前加了，synchronized 关键字，也就是同步的意思，因此Vector是线程安全的，而arraylist类中的方法没有加锁虽然线程不安全但是多线程访问该类效率明显高于Vector。那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于 2。
复制链接

扫一扫