简介
ArrayList是一个可动态调整数组大小的集合类,其类图关系如下:
![887d25501d1b55f1156843c9abe3a779.png](https://i-blog.csdnimg.cn/blog_migrate/af01cce3b8b40c178817ca605e352836.jpeg)
ArrayList类图
![5518dd7918c161f35cecf5a5e48df084.png](https://i-blog.csdnimg.cn/blog_migrate/fa0be313d27f6c498bae4cfb2ee1ce23.jpeg)
从属性与方法角度剖析ArrayList
属性解析
DEFAULT_CAPACITY:默认容量10,用于构造函数初始化与容量运算。
EMPTY_ELEMENTDATA:共享的空数组,调用ArrayList有参构造函数参数容量值为0(即一般考虑不再进行容量扩展)时赋给elementData。
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); }}public ArrayList(Collection extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { this.elementData = EMPTY_ELEMENTDATA; }}
DEFAULTCAPACITY_EMPTY_ELEMENTDATA:共享的空数组,与EMPTY_ELEMENTDATA区别在于该数组是用来容量运算的,调用ArrayList无参构造函数时会把该对象赋给elementData,添加元素时再重新计算扩容,所以一般建议使用有参构造函数赋予原始容量。
public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}
elementData:存储ArrayList的元素的数组缓冲区。size:ArrayList包含的元素数量,elementData数组的元素数量。MAX_ARRAY_SIZE:分配的最大数组大小,值为Integer.MAX - 8
方法解析
- add(E)添加元素
/** * (1) 数组末尾添加元素 */public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! // 容量值自增并将元素附加到数组末尾 elementData[size++] = e; return true;}/** * (2) 确保内部的容量能满足所需最小容量minCapacity */private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));}/** * (3) 根据数组所需的最小容量minCapacity进行容量计算 */private static int calculateCapacity(Object[] elementData, int minCapacity) { // 若元素数组为引用的空数组,则返回默认容量(10)与minCapacity之间的最大值,不为空则返回minCapacity if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity;}/** * (4) 根据数组所需的最小容量minCapacity确保精确的容量 */private void ensureExplicitCapacity(int minCapacity) { modCount++; // 判断添加元素后的元素数目是否大于数组长度,true则进行数组扩容,false则完成元素添加 if (minCapacity - elementData.length > 0) grow(minCapacity);}/** * (5) 根据数组所需的最小容量minCapacity判断是否扩容 */private void ensureExplicitCapacity(int minCapacity) { modCount++; // 判断添加元素后的元素数目是否大于数组长度,true则进行扩容,false则完成元素添加 if (minCapacity - elementData.length > 0) grow(minCapacity);}/** * (6) 重新建一个至少可以容纳最小容量minCapacity的数组并进行数组元素拷贝,消耗大 */private void grow(int minCapacity) { int oldCapacity = elementData.length; // 若所需最小容量minCapacity大于旧容量oldCapacity+oldCapacity右移1值,则新容量为minCapacity,反正新容量为旧容量运算值 int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; // 大容量数组,一般不会调用到 if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // 新建一个长度为newCapacity的数组并将旧数组元素负责过来 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;}
以下重新整理一下新增的的步骤:
- add()数组末尾添加元素
- ensureCapacityInternal()确保内部的容量能满足所需最小容量minCapacity
- calculateCapacity()根据数组所需的最小容量minCapacity进行容量计算
- ensureExplicitCapacity()根据数组所需的最小容量minCapacity确保精确的容量
- ensureExplicitCapacity()根据数组所需的最小容量minCapacity判断是否扩容,若需要则进行步骤6
- grow()重新建一个至少可以容纳最小容量minCapacity的数组并进行数组元素拷贝,消耗大,所以建议一般使用有参构建函数创建列表时设置好容量
由上述流程可以看出,ArrayList的add(E e)方法在容量足以确保的情况下效率是很高的,直接将新元素赋予数组元素的末尾下标+1即可,复杂度仅为O(1)。
- add(int, E)增元素
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++;}
该方法的主要核心在System.arraycopy()方法,该方法把elementData数组中的index位置起的size-index个元素(即index下标后的元素)复制到下标index+1,然后再把新的元素element赋到index下标位置。由于需要进行元素的位置逐个后移,所以性能耗费大,时间复杂度为O(n),n为指定位置后的元素数目。如在非末尾位置插入元素的操作较多,选择LinkedList效果会比ArrayList更好。
- addAll(Collection extends E>)添加元素
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;}
由上源码可以看到当添加集合元素时,也是需要进行数组拷贝的,不过是直接拷贝到列表数组末尾,时间复杂度由集合元素数目而定,即为O(n)。
- remove(Object)删元素
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;}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}
虽然删除元素的主要方面命名为fastRemove(),但从其代码依然可以看出这方法并不fast,指定位置删除元素后还要进行元素前移,性能耗费与指定位置添加差别不大,时间复杂度为O(n),n为指定位置后的元素数目。
如删除元素的操作较多,选择LinkedList效果会比ArrayList更好。
- set(int, E)改元素
public E get(int index) { rangeCheck(index); return elementData(index);}
替换指定下标数组元素,复杂度为O(1),效率高。
- get(int)查元素
public E get(int index) { rangeCheck(index); return elementData(index);}
根据下标获取数组元素,复杂度为O(1),效率高。
总结
ArrayList有以下特点:
- 添加元素性能因参数有所区别,但都需注意数组容量不足时ArrayList会进行扩容产生性能消耗add(E)在数组末尾添加元素,复杂度O(1)add(int, E)在数组指定位置添加元素,复杂度O(n),n为下标后的元素数目addAll(Collection)在数组末尾添加集合元素,复杂度O(n),n为集合中的元素数目
- 删除元素慢,remove()删除元素,后面元素需逐个移动,复杂度O(n),n为下标后的元素数目
- 更改效率高,set(index, E)直接根据下标替换数组元素,复杂度O(1)
- 查询效率高,get(index)直接根据下标获取数组元素,复杂度O(1)
综上,如果与指定下标元素增删操作更多的时候选择ArrayList会导致数组需要进行多次的元素移动,性能消耗十分大,该情况更适合使用LinkedList,因LinkedList增删元素时只需更改该元素上一个与下一个节点的指向即可,相当于从一个双向链表中摘除一个元素。