一 ArrayList与Vector区别
- vector是jdk1.0提供的,arrayList是jdk1.2提供的升级版
- vector是线程安全的,在所有写操作上都添加了synchronized关键字,arrayList是线场不安全的
- vector和arrayList的内部实现几乎一样,而且实现线场安全List list = Collections.synchronizedList(new ArrayList(...)),这是源码注释里写明的,相当于jdk已不推荐使用vector
- vector和arrayList都是动态数组,比数组的优点就是可以自己实现扩容,内部也是数组实现,只不过实现了动态扩容
- vector源码几乎和arrayList实现一致,所以下方主要以arrayList源码梳理
二 ArrayList与Vector类源码注释
查看源码类注释信息可以看到,内容几乎一样,arrayList只是说明了不是线场安全的;vector也表明arrayList是vector的改进版本;并在arrayList中并没有推荐vector作为线场安全的列表去实现,而是推荐List list = Collections.synchronizedList(new ArrayList(...))这种方式
三 ArrayList类定义
通过类定义可以看到,继承了AbstractList,实现了List接口,所以它是一个队列,支持相关的添加、删除、修改、遍历等功能;实现了RandomAccess表明可以快速随机访问,ArrayList可以通过脚标快速获取元素;实现Cloneable表明是可以被克隆的,自己实现了clone方法;实现Serializable表明支持序列化。
四 ArrayList常量定义
//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//指定初始容量为0时,返回该空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//不指定初始容量时,返回该空数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/*
存储ArrayList的元素的数组缓冲区。 ArrayList的容量是此数组缓冲区的长度。
添加第一个元素时,任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList都将扩展为DEFAULT_CAPACITY。
*/
transient Object[] elementData;
//元素个数,并不一定是容量
private int size;
//最大容量,避免在某些虚拟机下可能引起的OutOfMemoryError,减8的原因:数组作为一个对象,需要一定的内存存储对象头信息,对象头信息最大占用内存不可超过8字节。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
五 构造方法
/**
* 构造一个具有指定初始容量的空列表
*
*/
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);
}
}
/**
* 构造一个初始容量为10的空列表
* 以无参数构造方法创建 ArrayList 时,实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时,才真正分配容量。即向数组中添加第一个元素时,数组容量扩为 10。
* jdk7 new无参构造的ArrayList对象时,直接创建了长度是10的Object[]数组elementData 。
* jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 构造一个包含指定集合的元素的列表,其顺序由集合的迭代器返回
*/
public ArrayList(Collection<? extends E> c) {
//这里有个bug,c.toArray()可能不会返回Object[] ,官方bug库编号 626052,详情请参看https://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652
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 {
elementData = EMPTY_ELEMENTDATA;
}
}
六 新增方法
所有的新增方法都是先调扩容机制,判断是否需要扩容,如果需要扩容则扩容,然后进行对数组相应元素赋值
/**
* 将指定的元素追加到此列表的末尾。
*/
public boolean add(E e) {
//添加元素之前,先调用ensureCapacityInternal方法
ensureCapacityInternal(size + 1); // Increments modCount!!
//这里看到ArrayList添加元素的实质就相当于为数组赋值
elementData[size++] = e;
return true;
}
/**
*
* add方法内首先调用了此方法,内部多次调用,主要判断是否需要扩容
*/
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 判断是否为空数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 返回默认长度和当前传入后的size大的数值
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 为空数组则返回当前传入size大小
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 判断是否需要扩容,如果当前size已经大于当前数组长度就扩容
// overflow-conscious code
if (minCapacity - elementData.length > 0)
// 调用扩容方法
grow(minCapacity);
}
private void grow(int minCapacity) {
// 获取旧的数组长度
// overflow-conscious code
int oldCapacity = elementData.length;
// 计算新的数组长度,旧数组长度右移一位代表除2的1次方再加上原数组长度所以是1.5倍
// 如果数组长度是奇数则小于1.5倍,因为是一个int值,除不近则舍弃
int newCapacity = oldCapacity + (oldCapacity >> 1);
//然后检查新容量是否大于最小需要容量,若还是小于最小需要容量,那么就把最小需要容量当作数组的新容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果新容量大于 MAX_ARRAY_SIZE,进入 hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE,
//如果minCapacity大于最大容量,则新容量则为`Integer.MAX_VALUE`,否则,新容量大小则为 MAX_ARRAY_SIZE 即为 `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) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
七 ensureCapacity方法
此方法是对外提供的,官方希望你在有预期多次扩容的情况下,自己手动触发一次扩容机制,这样可以减少重复创建销毁数组,包括数组拷贝等性能消耗
/**
*
* 如有必要,增加此ArrayList实例的容量,以确保它至少可以容纳最小容量参数指定的元素数量
*/
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
八 删除
所有的删除方法都是先把相应位置删除移动出来,然后置空删除位置数值,计算size
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);
// 删除原有位置数值及size--
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
九 查找
剩下查找元素等都是遍历数组,判断equals方法,返回脚标
public E get(int index) {
// 验证是否越界
rangeCheck(index);
// 直接根据数组脚标返回元素
return elementData(index);
}
十 修改
修改就是通过操作数组位置替换值实现
public E set(int index, E element) {
// 验证越界
rangeCheck(index);
// 获取旧值
E oldValue = elementData(index);
// 把当前数组位置换为新值
elementData[index] = element;
// 返回旧值
return oldValue;
}
十一 System.arraycopy() 和 Arrays.copyOf()
ArrayList内部多次使用System.arraycopy() 和 Arrays.copyOf()方法,他们主要作用是拷贝原数组和新数组及扩容
// 从指定的源数组(从指定位置开始)复制数组到目标数组的指定位置。
// 数组组件的子序列从src引用的源数组复制到dest引用的目标数组。
// 复制的组件数等于length参数。
// 将源数组中位置srcPos至srcPos+length-1处的组件分别复制到目标数组的位置destPos至destPos+length-1 。
// 如果src和dest参数引用同一数组对象,则执行复制,就好像首先将srcPos到srcPos+length-1位置上的分量复制到具有length分量的临时数组,然后将临时数组的内容通过目标数组的destPos+length-1复制到位置destPos。
// src –源数组。 srcPos –源数组中的起始位置。 dest –目标数组。 destPos –目标数据中的起始位置。 length –要复制的数组元素的数量。
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
// 主要是拷贝一个新数组,并扩容为指定长度
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;
}