1. ArrayList的继承结构图
继承结构图
从继承结构图中可以看出来,,一般的设计都会是List接口定义所有的API接口,然后用抽象类AbstractList来实现常用的API接口,然后在实现类中定义具体的实现;
接口 ==> 抽象类 ==> 类
图中,ArrayList却去实现了List ,collection 的作者Josh说他写这代码的时候觉得这个会有用处，但是其实并没什么用，但因为没什么影响，就一直留到了现在。
2.ArrayList 的成员变量
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//序列化和反序列化id
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 指定该ArrayList容量为0时，返回该空数组。
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 当调用无参构造方法，返回的是该数组。
* 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 存放数据的数组
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* ArrayList的实际大小
*/
private int size;
/**
* The maximum size of array to allocate.
* Some VMs reserve some header words in an array.
* ArrayList的最大容量; -8 是因为JVM在数组中保留一些header。
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
3. ArrayList 的构造方法
3.1 无参构造器
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
}
当我们通过 ArrayList<String> arrayList = new ArrayList<>(); 时, 会将常量数组对象DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给 elementData 对象数组;
因为使用到空构造的情况很多,所以将DEFAULTCAPACITY_EMPTY_ELEMENTDATA定义为常量,主要为了节约空间
3.2 带容量的构造器
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public ArrayList(int initialCapacity) {
// 如果指定的容量大于0, 创建一个对象数组,指定容量为传入的参数,并赋值给elementData
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
// 如果指定的容量为0的话,将空的对象数组EMPTY_ELEMENTDATA赋值给elementData
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
//参数异常
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
}
3.3 带集合的构造器
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public ArrayList(Collection<? extends E> c) {
//将集合转化为数组,赋值给elementData
elementData = c.toArray();
// 若数组elementData的长度不等于0
if ((size = elementData.length) != 0) {
//每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型，那么就需要使用ArrayList中的方法去改造一下。
if (elementData.getClass() != Object[].class)
//将传入的数组赋值给elementData
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 若数组elementData的长度等于0
this.elementData = EMPTY_ELEMENTDATA;
}
}
}
4. ArrayList 的常用方法
4.1 add(E e)方法
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e; //在数组的末尾增加元素
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//minCapacity: 添加元素过后,ArrayList的大小
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//获取ArrayList的最大容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//如果ArrayList为空,则表示数组未初始化,则返回DEFAULT_CAPACITY
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; // 记录操作数
// 若数组的容量大于了数组的长度,就扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 扩容, 扩容1.5倍,并赋值为新的数组
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);
}
}
4.2 add(int index, E element)方法
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
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));
}
}
4.3 remove(int index)方法
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
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; // 返回删除的值
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
4.4 remove(Object o)方法
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public boolean remove(Object o) {
//ArrayList可以存放null
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
}
}
4.5 set(int index, Object o)方法
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public E set(int index, E element) {
rangeCheck(index);.// 检查数组下标
E oldValue = elementData(index);// 获取旧值
elementData[index] = element; //赋值新值
return oldValue; //返回旧值
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
4.6 E get(int index)方法
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public E get(int index) {
rangeCheck(index);// 检查数组索引
return elementData(index);//返回索引对应的元素
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
4.7 clear()方法
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
}
