ArrayList创建和add等各种api使用原理
ArrayList
允许空值和重复元素,当往 ArrayList 中添加的元素数量大于其底层数组容量时,其会通过 扩容 机制重新生成一个更大的数组。ArrayList
是非线程安全类,并发环境下,多个线程同时操作 ArrayList,会引发不可预知的异常或错误。
ArrayList创建源码
带有初始容量的构造方法
// 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) {
// 参数大于0,elementData初始化为initialCapacity大小的数组,即根据传入的参数大小创建数组
if (initialCapacity > 0) {
this.elementData = new Object\[initialCapacity\];
// 参数等于0,创建空数组
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
// 否则抛出异常,参数异常,初始化容量异常
} else {
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}
无参构造方法,即使用默认的size为10的空数组,
在构造方法中没有对数组长度进行设置,会在后续调用add方法的时候进行扩容
/**
* 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;
}
参数为集合的构造方法,将一个参数为Collection的集合转变为ArrayList(实际上就是将集合中的元素换为了数组的形式)。
/**
* Constructs a list containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
*
* @param c the collection whose elements are to be placed into this list
* @throws NullPointerException if the specified collection is null
*/
public ArrayList(Collection<? extends E> c) {
// 如果传入的集合为空,则c.toArray()抛出空指针异常
elementData = c.toArray();
// 如果传入的数组容量不为0 而且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;
}
}
ArrayList的add方法源码
/**
* Appends the specified element to the end of this list.
* 将指定元素添加到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;
}
// ensureCapacityInternal方法分析
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算出最少需要的容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 这里就是判断elementData数组是不是为空数组
//(使用的无参构造的时候,elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// 如果是,那么比较size+1(第一次调用add的时候size+1=1)和DEFAULT\_CAPACITY(为10)
// 那么显然容量为10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code 最少需要的容量大于元素总的数量
if (minCapacity - elementData.length > 0)
// 执行扩容方法
grow(minCapacity);
}
/**最大容量
- The maximum size of array to allocate.
- Some VMs reserve some header words in an array.
- Attempts to allocate larger arrays may result in
- OutOfMemoryError: Requested array size exceeds VM limit
*/
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.
- 扩容函数,保证扩容后的容量大于需要的最小容量,又小于Integer.MAX_VALUE
- @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
//获取旧数组的容量
int oldCapacity = elementData.length;
// 新数组的容量 = old+old/2,即扩容1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果新数组的容量比要求的最低容量还少,就使用最低容量作为新数组的容量
if (newCapacity - minCapacity < 0) newCapacity = minCapacity;
// 如果旧数组扩容1.5倍之后,比Integer.MAX_VALUE-8大,使用hugeCapacity比较二者
// 如果要求的最小容量大于Integer.MAX_VALUE-8就使用Integer.MAX_VALUE作为扩容后的容量,否则使用Integer.MAX_VALUE-8作为扩容后的容量
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);
}
// 判断得出新数组的容量需要扩容到多少
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) throw new OutOfMemoryError();
// 对minCapacity和MAX_ARRAY_SIZE进行比较
// 若minCapacity大,将Integer.MAX_VALUE作为新数组的大小
// 若MAX_ARRAY_SIZE大,将MAX_ARRAY_SIZE作为新数组的大小
// MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
当 要 add 进第1个元素时,minCapacity为(size+1=0+1=)1,在Math.max()方法比较后,minCapacity 为10。 然后紧接着调用ensureExplicitCapacity更新modCount的 值,并判断是否需要扩容
add方法执行流程总结 我们用一幅图来简单梳理一下,当使用无参构造的时候,在第一次调用add方法之后的执行流程
这是第一次调用add方法的过程,当扩容值capacity为10之后,
继续添加第2个元素(先注意调用ensureCapacityInternal方法传递的参数为size+1=1+1=2)
在ensureCapacityInternal方法中,elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA不成立,所以直接执行ensureExplicitCapacity方法
ensureExplicitCapacity方法中minCapacity为刚刚传递的2,所以第二个if判断(2-10=-8)不会成立,即newCapacity 不比 MAX_ARRAY_SIZE大,则不会进入
grow
方法。数组容量为10,add方法中 return true,size增为1。假设又添加3、4......10个元素(其中过程类似,但是不会执行grow扩容方法)
当add第11个元素时候,会进入grow方法时,计算newCapacity为15,比minCapacity(为10+1=11)大,第一个if判断不成立。新容量没有大于数组最大size,不会进入hugeCapacity方法。数组容量扩为15,add方法中return true,size增为11。
add(int index,E element)方法
//在元素序列 index 位置处插入
public void add(int index, E element) {
rangeCheckForAdd(index); //校验传递的index参数是不是合法
// 1. 检测是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
// 2. 将 index 及其之后的所有元素都向后移一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 3. 将新元素插入至 index 处
elementData[index] = element;
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0) //这里判断的index>size(保证数组的连续性),index小于0
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
add(int index, E element)方法(在元素序列指定位置( 假设该位置合理
)插入)的过程大概是下面这些
将新元素插入至序列指定位置,需要先将该位置及其之后的元素都向后移动一位,为新元素腾出位置。这个操作的时间复杂度为,频繁移动元素可能会导致效率问题,特别是集合中元素数量较多时。在日常开发中,若非所需,我们应当尽量避免在大集合中调用第二个插入方法。
ArrayList的remove方法
1、remove(int index) 按照下标删除
public E remove(int index) {
rangeCheck(index); //校验下标是否合法(如果index>size,旧抛出IndexOutOfBoundsException异常)
modCount++;//修改list结构,就需要更新这个值
E oldValue = elementData(index); //直接在数组中查找这个值
int numMoved = size - index - 1;//这里计算所需要移动的数目
//如果这个值大于0 说明后续有元素需要左移(size=index+1)
//如果是0说明被移除的对象就是最后一位元素(不需要移动别的元素)
if (numMoved > 0)
//索引index只有的所有元素左移一位 覆盖掉index位置上的元素
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//移动之后,原数组中size位置null
elementData[--size] = null; // clear to let GC do its work
//返回旧值
return oldValue;
}
// src:源数组
// srcPos:从源数组的srcPos位置处开始移动
// dest:目标数组
// desPos:源数组的srcPos位置处开始移动的元素,这些元素从目标数组的desPos处开始填充
// length:移动源数组的长度 public static native void (Object src, int srcPos, Object dest, int destPos,int length);
删除过程如下图所示
2、remove(Object o) 按照元素删除,会删除和参数匹配的第一个元素
public boolean remove(Object o) {
//如果元素是null 遍历数组移除第一个null
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//遍历找到第一个null元素的下标 调用下标移除元素的方法
fastRemove(index);
return true;
}
} else {
//找到元素对应的下标 调用下标移除元素的方法
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
//按照下标移除元素(通过数组元素的位置移动来达到删除的效果)
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
}
ArrayList的其他方法
ensureCapacity方法
最好在 add 大量元素之前用 ensureCapacity 方法,以减少增量从新分配的次数
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)? 0
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
ArrayList总结
(1) ArrayList
是一种变长的集合类,基于定长数组实现,使用默认构造方法初始化出来的容量是10(1.7之后都是延迟初始化,即第一次调用add方法添加元素的时候才将elementData容量初始化为10)。
(2) ArrayList
允许空值和重复元素,当往 ArrayList 中添加的元素数量大于其底层数组容量时,其会通过 扩容 机制重新生成一个更大的数组。 ArrayList
扩容的长度是原长度的1.5倍
(3)由于 ArrayList
底层基于数组实现,所以其可以保证在 O(1)
复杂度下完成随机查找操作。
(4) ArrayList
是非线程安全类,并发环境下,多个线程同时操作 ArrayList,会引发不可预知的异常或错误。
(5)顺序添加很方便
(6)删除和插入需要复制数组,性能差(可以使用LinkindList)
(7)Integer.MAX_VALUE - 8 :主要是考虑到不同的JVM,有的JVM会在加入一些数据头,当扩容后的容量大于MAX_ARRAY_SIZE,我们会去比较最小需要容量和MAX_ARRAY_SIZE做比较,如果比它大, 只能取Integer.MAX_VALUE,否则是Integer.MAX_VALUE -8。这个是从jdk1.7开始才有
- END -
▐往期推荐
如果你觉得文章不错,文末的赞 ???? 又回来啦,记得给我「点赞」和「在看」哦~