List集合之ArrayList（一）通过源码看特性(1)，最新版

ArrayList容器的本质是一个Object[]类型的数组。

即ArrayList容器存储的元素，本质都是存储在Object[]类型数组中。

ArrayList中定义了实例变量 Object[] elementData 来作为底层数组。

构造器

===

public ArrayList()

/**

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

/**

Constructs an empty list with an initial capacity of ten.

public ArrayList() {

this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

ArrayList无参构造器创建对象时，elementData固定赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

其中DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空的Object[]的数组。

所以使用new ArrayList()得到的是一个空的Object[]的数组，且该空数组是一个特定对象DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

public ArrayList(int initialCapacity)

/**

Shared empty array instance used for empty instances.

private static final Object[] EMPTY_ELEMENTDATA = {};

/**

Constructs an empty list with the specified initial capacity.
@param initialCapacity the initial capacity of the list
@throws IllegalArgumentException if the specified initial capacity
```
    is negative
```

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

}

ArrayList带一个int形参的构造器创建对象时，可以由外部指定一个初始容量initialCapacity。

构造器内部根据initialCapacity来创建一个对应长度的数组。

当initCapacity>0时，构造器内部正常创建一个new Obejct[initialCapacity]对象给elementData。

当initCapacity=0时，构造器就将固定的EMPTY_ELEMENTDATA空Object[]数组赋值给elementData。

当initCapacity<0时，构造器就抛出异常，因为数组的长度不能是负数。

其中EMPTY_ELEMENTDATA也是一个空的Object[]数组。那么此处为什么不将DEFAULTCAPACITY_EMPTY_ELEMENTDATA给elementData呢？

而要使用本质上重复的EMPTY_ELEMENTDATAn呢？

虽然DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA都是空Object[]数组，

但是它们的内存地址值不同，是两个不同的对象。

而后面针对不同构造器初始化的elementData扩容时，会有不同的扩容方案。

比如使用ArrayList()创建对象时，使用该无参构造器的人不确定要初始化的容器容量，

可能很大，也可能很小，所以需要系统的扩容方案偏向折中。

比如使用ArrayList(int initialCapacity)创建对象时，

使用该构造器的人应该已经确切知道容器容量的大小了，

所以就算后期数据超了事先预定的容器容量，也应该不会超过太多，

所以需要系统的扩容方案偏向保守。

但是不论是无参构造器，还是指定初始容器容量的构造器，都是有可能定义一个容量为0的容器的。

所以为了后期扩容时，系统知道选择的是什么构造器，就给

无参构造器专门定义了一个地址值固定的DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空Object[]数组。

其它构造器定义了EMPTY_ELEMENTDATA的空Object[]数组。

public ArrayList(Collection<? extends E> c)

public ArrayList(Collection<? extends E> c) {

Object[] a = c.toArray();

if ((size = a.length) != 0) {

if (c.getClass() == ArrayList.class) {

elementData = a;

} else {

elementData = Arrays.copyOf(a, size, Object[].class);

}

} else {

// replace with empty array.

elementData = EMPTY_ELEMENTDATA;

}

ArrayList带一个Collection实现类对象c的形参的构造器，该构造器创建对象，本质是将c中的元素转存到ArrayList容器中。

首先需要判断c是否是空集合，如果是空集合，则直接创建一个空的ArrayList容器返回即可。

这里底层elementData赋值为EMPTY_ELEMENTDATA。

为什么这里不选择使用DEFAULTCAPCITY_EMPTY_ELEMENTDATA呢？

我们需要知道DEFAULTCAPCITY_EMPTY_ELEMENTDATA是给容器容量不确定的情况使用的。

而当前构造器是将一个已经存在的集合转成ArrayList集合，

那么可以理解为要被转的集合是一个已知元素个数的数据源，

那么我们要创建的ArrayList容器的容量就是已知的。所以选择了EMPTY_ELEMENTDATA。

如果不是空集合，则说明c中有元素。那么就将c中的元素取出来存到新的ArrayList集合中就行了。

以上是大致实现思路。但是具体实现如下：

首先c.toArray()，将c转成的数组向上转型赋值给了Object[]数组a。

然后通过判断a.length是否为0，来判断c集合中是否由元素，

如果a.length == 0，则c中没有元素，那么就将elementData = EMPTY_ELEMENTDATA.

如果a.length != 0,则c中有元素，那么就继续判断c的运行时类型是不是ArrayList,

如果是，那么c.toArray()得到的返回值就是Object[]数组，

那么就不需要新创建一个数组给elementData了。

如果不是，那么c.toArray()得到的返回值就可能不是Object[]数组，

那么就需要创建一个新的Object[]数组来转移c.toArray()数组中的元素后，赋值给elementData。

这样新创建的ArrayList对象的底层数组elementData的初始化就完成了。

特性证明

通过ArrayList构造器的实现，我们可以知道ArrayList的底层数据结构是数组，且是一个Object[]类型的数组。则可以证明特性

集合元素类型可以不一致。证明：任何引用类型的元素都可以存入Object[]数组。

集合元素类型只能是引用类型。证明：存入Obejct[]数组的元素类型只能是引用类型。

集合元素只能是单列数据。证明：数组只能存单列数据。

ArrayList元素有索引。证明：数组存储的元素都有索引。

插入元素

====

public boolean add(E e)

/**

Appends the specified element to the end of this list.
@param e element to be appended to this list
@return true (as specified by {@link Collection#add})

public boolean add(E e) {

ensureCapacityInternal(size + 1); // Increments modCount!! //ensureCapacityInternal用于对elementData数组进行扩容，传入的参数是扩容的最小容量，即size+1,即比当前elementData容量多一个元素的容量

elementData[size++] = e;

return true;

}

private void ensureCapacityInternal(int minCapacity) {

ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));//calculateCapacity用于计算最适合elementData的扩容容量

}

private static int calculateCapacity(Object[] elementData, int minCapacity) {

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {// 当elementData==DEFAULTCAPACITY_EMPTY_ELEMENTDATA时，说明elementData刚被new ArrayList()创建，而且当前是第一次add操作

return Math.max(DEFAULT_CAPACITY, minCapacity);//由于此时minCapacity是size+1，即为1，而DEFAULT_CAPACITY是10，所以calculateCapacity方法返回10

}

return minCapacity;// 如果elementData!=DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则说明1.elementData是被new ArrayList()创建的,但当前不是第一次add操作 2.elementData不是被new ArrayLsit()创建的。此时minCapacity就是size+1

}

private void ensureExplicitCapacity(int minCapacity) {

modCount++; // modCount提示迭代器是否在迭代过程中有元素被增加或删除，若有，则快速失败

// overflow-conscious code

if (minCapacity - elementData.length > 0)// ，minCapacity可能是size+1或者10，如果minCapacity - elementData.length<=0,则elementData数组无需扩容，否则需要扩容

grow(minCapacity);

}

/**

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) {

// overflow-conscious code

int oldCapacity = elementData.length;//将当前elementData数组长度定义为oldCapacity

int newCapacity = oldCapacity + (oldCapacity >> 1);//定义扩容容量为newCapacity,且为oldCapacity的1.5倍

if (newCapacity - minCapacity < 0)// 如果最小扩容容量比 elementData数组长度的1.5倍还大，则将最小扩容容量作为最终扩容容量，否则就将老容量1.5倍，作为最终扩容容量

newCapacity = minCapacity;

if (newCapacity - MAX_ARRAY_SIZE > 0)// 检查最终扩容容量是否比（int最大值-8）大

newCapacity = hugeCapacity(minCapacity);// 如果是的话，则提供一个默认扩容容量

// minCapacity is usually close to size, so this is a win:

elementData = Arrays.copyOf(elementData, newCapacity);//最终将老的elementData数组中的数据复制到一个新的，容量为newCapacity的数组中，并最终赋值给elementData

}

private static int hugeCapacity(int minCapacity) {

if (minCapacity < 0) // overflow

throw new OutOfMemoryError();

return (minCapacity > MAX_ARRAY_SIZE) ?

Integer.MAX_VALUE :

MAX_ARRAY_SIZE;

}

@SuppressWarnings(“unchecked”)

public static T[] copyOf(T[] original, int newLength) {

return (T[]) copyOf(original, newLength, original.getClass());

}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {

@SuppressWarnings(“unchecked”)

T[] copy = ((Object)newType == (Object)Object[].class)

? (T[]) new Object[newLength]

(T[]) Array.newInstance(newType.getComponentType(), newLength);

System.arraycopy(original, 0, copy, 0,

Math.min(original.length, newLength));

return copy;

}

add(E e)方法是在ArrayList尾部插入一个元素e。

该方法有五部分逻辑

1.计算最小扩容容量

2.判断是否需要扩容

3.计算实际扩容容量

4.进行扩容

5.扩容后add操作

1.计算最小扩容容量

默认最小扩容容量就是当前elementData容量+1

但是如果是new ArrayList()后，首次add操作，则最小扩容容量为10

2.判断是否需要扩容

如果

最小扩容容量比当前elementData的容量小，则说明elementData容量是足够当前操作，即无需扩容。

如果

最小扩容容量比当前elementData的容量大，则说明elementData容量不足，无法支持当前操作，需要立即扩容。

3.计算实际扩容容量（前提：第2步判断需要扩容）

默认实际扩容容量是当前elementData容量的1.5倍。

若最小扩容容量比默认实际扩容容量大，则说明默实际认扩容容量不足，则默认实际扩容容量需要改为最小容量的值。

若最小扩容容量比默认实际扩容容量小，则说明默认实际扩容容量足够。

继续比较默认实际扩容容量和MAX_ARRAY_SIZE的大小：

如果默认实际扩容容量比MAX_ARRAY_SIZE还要大，

则说明默认实际扩容容量已经超出了常规数组的最大容量，

则再用最小扩容容量和MAX_ARRAY_SIZE比，

若连最小扩容容量也比MAX_ARRAY_SIZE大，

则实际扩容容量为Integer.MAX_VALUE，否则为MAX_ARRAY_SIZE。

如果默认实际扩容容量比MAX_ARRAY_SIZE小，则实际扩容容量为默认实际扩容容量。

4.进行扩容

Arrays.copyOf(elementData,实际扩容容量)

System.arrayCopy(elementData,0,new Object[实际扩容容量]，0，elementData.length)；

即将老数组elementData，从第0位开始,到第elementData.length-1位的元素全部复制到新数组的第0位，到到第elementData.length-1位

5.扩容后add操作

elementData[size++] = e;

扩容前，elementData数组的最大索引是size-1,元素个数是size

扩容后，elementData数组的最大索引至少是size,元素个数是size++

所以扩容后add操作是elementData[size++] = e;

public void add(int index, E element)

/**

Inserts the specified element at the specified position in this
list. Shifts the element currently at that position (if any) and
any subsequent elements to the right (adds one to their indices).
@param index index at which the specified element is to be inserted
@param element element to be inserted
@throws IndexOutOfBoundsException {@inheritDoc}

public void add(int index, E element) {

rangeCheckForAdd(index);

ensureCapacityInternal(size + 1); // 对数组进行扩容，和add(E e)扩容逻辑一致，注意该步该返回的数组是elementData = Arrays.copyOf(elementData,扩容后长度)，即elementData扩容了，且前xx位元素还是老的数组的元素

System.arraycopy(elementData, index, elementData, index + 1,

size - index);// 该步将elementData的index（插入索引位置）的元素，以及它后面的元素，全部往后挪了一位存储。这样就空出了index位置了

elementData[index] = element;// 完成对index位置元素的插入

size++;//完成元素个数的更新

}

/**

A version of rangeCheck used by add and addAll.

private void rangeCheckForAdd(int index) {

if (index > size || index < 0)//由于底层数组的索引是[0,index-1],所以可以插入0（头部）,index（尾部），或(0,index)（中间）之间的位置，不能插入其他的位置

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

add(int index,E element)该方法是在ArrayList容器的index位置插入一个元素。

其中index位置可以是当前容器的头部（0）,尾部（size）,或者中间（0~size）任意位置插入。

该方法有六步

1.index检查

2.计算最小扩容容器

2.判断是否需要扩容

3.计算实际扩容容量

4.进行扩容

5.空出index位置

6.插入元素到index位置

其中2，3，4步和add(E e)方法一致。

1.index检查

插入元素的位置不能是头部之前的位置，也不能是尾部之后的位置

所以 index >= 0 && index <= size

2，3，4.进行扩容

举个例子：

扩容前，elementData.length,即容器容量为3，存储的元素为{1，2，3}，现在要在索引1处插入1.5元素。

由于此时minCapacity=4 , minCapacity>elementData.length,所以需要进行扩容

默认扩容大小为3+3*0.5 = 4，所以就扩容到4，并将老数组中元素按照索引位置转移到新数组中

elementData = Arrays.copyOf(elementData,4);

即扩容后的新数组为：

elementData = {1，2，3，null}

5.空出index位置

System.arraycopy(elementData,index,elementData,index+1,size-index)

此时 size还没有改变，还是老数组的元素个数，即3。

index是要插入的索引位置，即为1。

System.arraycopy(elementData,1,elementData,2,2);

该步操作后，elementData的数组变为

{1,2,2,3}

6.插入元素到index位置

elementData[index] = element;后即完成插入操作

elementData = {1,1.5,2,3}

public boolean addAll(Collection<? extends E> c)

/**

Appends all of the elements in the specified collection to the end of
this list, in the order that they are returned by the
specified collection’s Iterator. The behavior of this operation is
undefined if the specified collection is modified while the operation
is in progress. (This implies that the behavior of this call is
undefined if the specified collection is this list, and this
list is nonempty.)
@param c collection containing elements to be added to this list
@return true if this list changed as a result of the call
@throws NullPointerException if the specified collection is null

public boolean addAll(Collection<? extends E> c) {

Object[] a = c.toArray();//将c转成数组

int numNew = a.length;

ensureCapacityInternal(size + numNew); // Increments modCount// 最小扩容容量=当前数组容量+c集合元素个数

System.arraycopy(a, 0, elementData, size, numNew);// 将c中元素复制到新数组的尾部

size += numNew;//ArrayList集合元素个数变为size+numNew

return numNew != 0;

}

addAll(Collection c)

该方法是ArrayList重写了List接口的抽象方法addAll(Collection c)。

该方法含义是将c集合中的元素按顺序插入到调用者ArrayList集合的尾部。

具体实现逻辑和add(E e)大致相同。只是add(E e)是只添加一个元素，而add(Collection c)是添加多个元素。

public boolean addAll(int index, Collection<? extends E> c)

/**

Inserts all of the elements in the specified collection into this
list, starting at the specified position. Shifts the element
currently at that position (if any) and any subsequent elements to
the right (increases their indices). The new elements will appear
in the list in the order that they are returned by the
specified collection’s iterator.
@param index index at which to insert the first element from the
```
         specified collection
```
@param c collection containing elements to be added to this list
@return true if this list changed as a result of the call
@throws IndexOutOfBoundsException {@inheritDoc}
@throws NullPointerException if the specified collection is null

public boolean addAll(int index, Collection<? extends E> c) {

rangeCheckForAdd(index);

Object[] a = c.toArray();

int numNew = a.length;

ensureCapacityInternal(size + numNew); // Increments modCount // 最小扩容容量 = 当前数组容量 + c集合中的元素个数

int numMoved = size - index;

if (numMoved > 0)

System.arraycopy(elementData, index, elementData, index + numNew,

numMoved);

System.arraycopy(a, 0, elementData, index, numNew);

size += numNew; // 插入后，ArrayList集合元素的个数变为size+numNew

return numNew != 0;

}

addAll(int index, Collection c)

该方法是ArrayList重载的方法。

该方法含义是在当前ArrayList集合的index索引处，插入c集合中的元素。

该方法实现方案和add(int index,E e)大致一致。

特性证明

add(E e)

add(int index,E e)

两个方法的实现证明了，ArrayList的集合元素是基于索引操作的，所以

1.ArrayList集合元素是有索引的。

且这两个方法实现类动态扩容，即证明

2.ArrayList集合的长度是可变的

另外，在add元素时没有特别检查元素本身是否重复

3.ArrayList集合的元素是可重复的

其次，add(E e)操作插入的元素，是将元素插入到当前底层数组的尾部

add(int index,E e)是将元素插入到底层数组指定索引处。

且元素取出的顺序就是插入的顺序，所以，证明：

4.ArrayList集合的元素是有序的

删除元素

====

public E remove(int index)

/**

Removes the element at the specified position in this list.
Shifts any subsequent elements to the left (subtracts one from their
indices).
@param index the index of the element to be removed
@return the element that was removed from the list
@throws IndexOutOfBoundsException {@inheritDoc}

public E remove(int index) {

rangeCheck(index);//检查要删除的索引是否合法，要删除的索引必须是elementData已有元素的索引

modCount++;

E oldValue = elementData(index);// 获取要删除索引上的元素，该方法执行完后需要返回被删除的元素

int numMoved = size - index - 1;// （假设已经删除了索引上的元素，那么被删除索引后面的元素，需要自动往前挪动一位），这里numMoved是指有几个元素需要挪动。理解：要删除index位置的元素，那么index+1到size-1位置上元素，要往前挪，则一共有size-1-index个元素需要挪动位置

if (numMoved > 0)

System.arraycopy(elementData, index+1, elementData, index,

numMoved);//进行挪位，即将elementDat中从index+1位置开始的numMoved个元素，复制到elementData中的index位置开始的numMoved个元素的位置上

elementData[–size] = null; // clear to let GC do its work//由于元素都往前挪动了一位，所以理论上数组的最后一个元素应该是空的，所以这里将elementData[size-1]的元素设置为了null。另外size是指集合的元素个数，而由于已经删除了一个元素，所以–size

return oldValue;// 返回删除操作前，保留的被删除的元素，告诉外部删除了哪个元素

}

/**

Checks if the given index is in range. If not, throws an appropriate
runtime exception. This method does not check if the index is
negative: It is always used immediately prior to an array access,
which throws an ArrayIndexOutOfBoundsException if index is negative.

private void rangeCheck(int index) {

if (index >= size)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

@SuppressWarnings(“unchecked”)

E elementData(int index) {

return (E) elementData[index];

}

remove(int index)

删除集合中指定索引处元素。即删除底层数组中指定索引处的元素。

具体实现：

1.检查需要删除元素的index是否合法

2.计算挪位数

3.进行挪位

4.挪位后，将尾部多余元素设置为null

5.更新size，即更新集合元素个数

关于挪位实现：

举个例子：当前有数组 Objetc[] arr = {1,2,3,4,5,6};

现在需要把索引1处的元素删除，且索引2处的元素自动填补到被删除的索引1处，索引3自动填补到索引2，…

即：删除索引1位置元素后：

{1，null,3,4,5,6}

挪位后

{1,3,4,5,6,null}

理论上应该这样实现。但是这样实现不符合最简代码逻辑。

关于挪位实现：

真实实现逻辑：

当前有数组 Objetc[] arr = {1,2,3,4,5,6};

现在想把arr中索引1处的元素删除。其实代码实现删除的方式有很多中，覆盖了该索引处元素也算是删除。

System.arraycopy(arr,2,arr,1,4)

这行代码即可实现对索引1处元素的覆盖，即删除。

代码含义是：将arr数组从索引2开始的4个元素，复制到arr数组从索引1开始的4个元素中。

即可实现挪位，即将被删除索引1处后面的元素，自动往前面移动一位。

这行代码的运行结果是：

arr = {1,3,4,5,6,6}

这样的结果显然不符合要求，因为虽然已经删除了索引1处的元素，并已经将删除元素后面的元素自动往前挪动了一位。但是挪动后，数组的最后一个元素显得有点突兀，

因为我们期望删除索引1后的数组是{1,3,4,5,6}或者是{1,3,4,5,6,null}

最简单解决方案就是，我们直接将arr[size-1]元素设置为null，即数组最后一个元素设置为null。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

最后的最后

面试题千万不要死记，一定要自己理解，用自己的方式表达出来，在这里预祝各位成功拿下自己心仪的offer。
需要完整面试题的朋友可以点击蓝色字体免费获取

大厂面试题

面试题目录

始的4个元素，复制到arr数组从索引1开始的4个元素中。

即可实现挪位，即将被删除索引1处后面的元素，自动往前面移动一位。

这行代码的运行结果是：

arr = {1,3,4,5,6,6}

因为我们期望删除索引1后的数组是{1,3,4,5,6}或者是{1,3,4,5,6,null}

最简单解决方案就是，我们直接将arr[size-1]元素设置为null，即数组最后一个元素设置为null。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

[外链图片转存中…(img-kPFvDdQm-1712168646477)]

[外链图片转存中…(img-9ZZw28NH-1712168646477)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

[外链图片转存中…(img-2MgSDOx2-1712168646478)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

最后的最后

[外链图片转存中…(img-x1KcDJCa-1712168646478)]

[外链图片转存中…(img-0j9jBXtG-1712168646478)]

[外链图片转存中…(img-JNbOHe8p-1712168646478)]

[外链图片转存中…(img-GluQTq7l-1712168646479)]