一、ArrayList概述
1.1 表ADT
介绍ArrayList集合和LinkedList集合之前我们必须要对表ADT（抽象数据类型）有一定的了解。
抽象数据类型（ADT）
抽象数据类型是带有一组操作的一些对象的集合。
表ADT
我们将处理形如A0，A1，A2，……，An-1的一般的表。我们说这个表的大小是N。大小为0的特殊的表称为空表。
对于除空表外的任何表，我们说Ai后继Ai-1并称Ai-1前驱Ai。
表ADT的两种实现方式
表的数组实现
对于表的所有操作都可以通过使用数组来实现。
表的链表实现
链表由一系列节点组成，这些节点不必在内存中相连。每个节点均还有表元素和到包含该元素后继元的节点的链。
表的数组实现
对于表的所有这些操作都可以通过使用数组来实现。虽然数组是由固定容量创建的，但在需要的时候可以用双倍的容量创建一个不同的数组。（注意这里的双倍！不是ArrayList的扩容倍数）
//模拟数组的扩容
int[] arr = new int[10];
....//一些操作
//下面我们需要对arr数组进行扩容
int[] newArr = new int[arr.length*2]
for(int i=0;i<arr.length;i++){
newArr[i] = arr[i];
}
arr = newArr;
数组的实现可以使得printList以线性时间被执行，而findKth操作则花费常数时间，这个就是我们想要的对表操作的预期。但是，插入和删除的花费却不能达到预期。
在最坏的情况下，在位置0插入元素则需要将表中的每一个元素后移一个位，为插入元素空出空间，删除也是这样。
在java语言中，对于ListADT的数组实现中最为流行的就是ArrayList类
1.2 ArrayList类
ArrayList代表长度可变的数组。允许对元素进行快速的随机访问，但是向ArrayList中插入与删除元素的速度较慢。
ArrayList由java.util包中的List接口指定。List接口继承了Collection接口。
ArrayList类的数据结构
容量：CAPACITY ； 实际大小：size；
ArrayList底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。
二、源码分析
2.1 ArrayList继承结构和层级关系
源码代码：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
层级关系图：
- ArrayList<>：说明ArrayList支持泛型。
- extends AbstractList :继承了AbstractList。AbstractList提供List接口的骨干实现，以最大限度地减少“随机访问”数据存储（如ArrayList）实现Llist所需的工作。
- implements List：实现了List。实现了所有可选列表操作。
- implements RandomAccess：表明ArrayList支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。
- implements Cloneable：表明其可以调用clone()方法来返回实例的field-for-field拷贝。
- implements java.io.Serializable：表明该类具有序列化功能。
2.2 ArrayList类的属性
//序列化id
private static final long serialVersionUID = 8683452581122892189L;
//默认的初始化容量
private static final int DEFAULT_CAPACITY = 10;
//一个空数组，在ArrayList容量为0时，返回该空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//一个空数组，当调用无参构造方法，返回的就是这个空数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//保存添加到ArrayList中的元素。
//ArrayList的容量就是该数组的长度
//被标记为transient，在对象被序列化的时候不会被序列化
transient Object[] elementData;
//ArrayList的实际大小（数组包含元素的个数）默认为0
private int size;
DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是构造时默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回的。
elementData在初始时是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，当第一个添加元素后，数组将扩容到DEFAULT_CAPACITY（10）.
2.3构造方法
三种构造方法的源码：
//第一个构造方法
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() {
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;
}
}
-
第一个构造方法：ArrayList(int initialCapacity)：
- initialCapacity > 0：实例化数组elementData，将传递的参数作为数组的大小。
- initialCapacity = 0：将空数组赋给elementData。（DEFAULTCAPACITY_EMPTY_ELEMENTDATA）
- initialCapacity <0：抛出异常
-
第二个构造方法：ArrayList()；
构造一个容量为10的空数组，将 DEFAULTCAPACITY_EMPTY_ELEMENT DATA赋给elementData 。elementData初始化成一个Object[]类型。当add（）第一个元素时，elementData会变成默认容量：10. -
第三个构造方法：ArrayList(Collection<? extends E> c)
构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。第二个有参构造方法构造时赋的值是它的父类Collection对象。- 将collection对象转换为数组，然后将数组的地址赋给elementData。
- 如果elementData的实际大小等于0，就将EMPTY_ELEMENTDATA赋给它。
- 如果不为0，则执行Arrays.copy方法，把collection对象的内容（可以理解为深拷贝）copy到elementData中。
2.4 主要方法
get（）方法：
/**
* Returns the element at the specified position in this list.
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
/**
* 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));
}
/**
* Constructs an IndexOutOfBoundsException detail message.
* Of the many possible refactorings of the error handling code,
* this "outlining" performs best with both server and client VMs.
*/
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
// Positional Access Operations
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
get（）方法首先先判断有没有越界（rangeCheck（）），如果越界则抛出异常，错误信息是索引和数组的实际长度），没有越界则通过数组下标返回元素。
set（）方法
/**
* Replaces the element at the specified position in this list with
* the specified element.
*
* @param index index of the element to replace
* @param element element to be stored at the specified position
* @return the element previously at the specified position
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
set()方法首先也是判断索引有没有越界，如果越界一样抛出异常。没有越界则将旧的元素赋值给oldValue存放，然后将新元素放入，最后返回oldValue。
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;
}
//数组容量检查，不够时则进行扩容，只供类内部使用
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//用来计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
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);
}
这个add 方法是在list的末尾添加一个元素。
size是数组中元素的个数，判断size+1个数数组是否可以容纳，如果可以容纳直接可以在size+1的位置下添加元素，如果容纳不下就选择扩容。
- calculateCapacity（）方法用来计算需要容量，如果elementData空的，那么就返回默认容量10，如果不为空就返回默认容量与需要容量的最大值。
- ensureExplicitCapacity（）方法用来判断是否需要扩容，比较需要容量与实际容量的大小，如果实际容量小于需要容量则选择扩容，调用方法grow（）。
grow（）代码：
/**
* 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
//将elementdata的长度赋值给oldCapacity。
int oldCapacity = elementData.length;
//扩容。新的容量=当前容量+当前容量/2.即将当前容量增加一半（当前容量增加1.5倍）。
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:
//新的容量大小已经确定好了，就copy数组，改变容量大小。
elementData = Arrays.copyOf(elementData, newCapacity);
}
综上代码总结：grow（）方法就是将原来的数组长度扩容到原来的1.5倍。然后copy一个新的数组赋给elementData。
remove()方法
/**
* 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);
modCount++;
//记录索引处的元素
E oldValue = elementData(index);
//删除指定元素后，需要左移的元素个数
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
//返回被删除的元素
return oldValue;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
