ArrayList源码分析
1、属性
/**
* 默认初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 若自定义容量是0，则会默认用它来初始化ArrayList，或者用于空数组替换。
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 若没有自定义容量，则会使用它来初始化ArrayList。或者用于空数组比对。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* ArrayList底层用到的数组。
* 非私有，不允许该属性序列化
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* 实际ArrayList集合大小
*/
private int size;
/**
* 可分配的最大容量
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
transient Object[] elementData分析
虽然elementData声明的是transient，但在网络传输时elementData的值很正常，并没有出现空值。原因： ArrayList在序列化时会调用void writeObject(java.io.ObjectOutputStream s) 方法，将size和element写入ObjectOutputStream；反序列化时调用void readObject(java.io.ObjectInputStream s) 从ObjectInputStream获取size和element，再回复到elementData。
这么做的好处在于elementData是一个缓存数组，通常会预留一些容量，等容量不足时再扩充容量，那么有些空间可能没有实际存储元素，采用上述方法序列化时，就可以保证只序列化实际存储的元素，而不是整个数组，从而节省时间和空间。
/**
* Save the state of the <tt>ArrayList</tt> instance to a stream (that
* is, serialize it).
*
* @serialData The length of the array backing the <tt>ArrayList</tt>
* instance is emitted (int), followed by all of its elements
* (each an <tt>Object</tt>) in the proper order.
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
/**
* Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
* deserialize it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
构造方法分析
根据initialCapacity初始化一个空数组，如果值为0，则初始化一个空数组。
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（DEFAULT_CAPACITY）。
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;
}
}
c.toArray might (incorrectly) not return Object[] (see 6260652) 一个官方bug，public Object[] toArray()返回的类型不一定就是Object[]，取决于其返回的实际类型。
// 测试1
public class Test {
public static void main(String[] args) {
List<String> ss = new LinkedList<String>(); // LinkedList toArray() 返回的本身就是 Object[]
ss.add("123");
Object[] objs = ss.toArray();
objs[0] = new Object();
ss = new ArrayList<String>();
objs = ss.toArray();
System.out.println(objs.getClass());
objs[0] = new Object(); // throw java.lang.ArrayIndexOutOfBoundsException
}
}
测试1是抛出官方错误。
// 测试2
public class Father {
}
public class Son extends Father {
}
public class Test2 {
public static void main(String[] args) {
Son[] sons = new Son[]{new Son(), new Son()};
System.out.println(sons.getClass());
Father[] fathers = sons;
System.out.println(fathers.getClass());
fathers[2] = new Father(); // thorw ava.lang.ArrayIndexOutOfBoundsException
}
}
测试2中fathers 实际类型是Son[]，由于数组中元素类型都是son类型的，存储new Father()时，向下转型发生异常。也就意味着1个Object[]数组，并不一定代表着可以把Object对象存储进去。
1、抽象类(接口)其具体类型，取决于实例化时所采用的导出类的类型。
2、子类实现和父类同名的方法，仅仅返回值不一致时，默认调用的是子类的那个实现方法。
主干方法
trimToSize()
/**
* 用来最小化实例存储。将容器的大小调整为当前元素所占的容量大小。
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
clone()
/**
* 克隆出一个新数组
*/
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
add(E e)
在数组末尾添加元素
public boolean add(E e) {
// 计算容量
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
/**
* 计算容量
* 如果elementData为空，则返回默认容量和Size+1中的最大值。
* 若elementData不为空，则执行ensureExplicitCapacity()方法
*/
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* 确保容量可用
* 若(size + 1) - elementData.length > 0，则证明数组已满，需要扩容，调用grow(minCapacity)
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* 扩容
* 1、获取当前数组长度 => oldCapacity
* 2、oldCapacity>>1 表示将oldCapacity右移一位(位运算)，相当于除2。再加上1，相当于新容量扩容1.5倍。
* 3、如果新容量比最大值还要大，则需要将新容量赋值为VM要求的最大值。
* 4、将elementData拷贝到一个新的容器中。
*/
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);
}
/**
* 将新容量赋值为VM的最大值
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
为什么要size+1
size + 1表示的含义是：
1、如果集合添加元素成功后，集合中的实际元素个数。
2、为了确保扩容时不会出现错误。
假如不做+1处理，默认size是0，则0+(0 >> 1) = 0。
add(int index, E element)
/**
* 在指定索引位添加元素
*/
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));
}
System.arraycopy(elementData, index, elementData, index + 1, size - index) ：
// native表示调用非本地方法（调用非java代码的接口）
/**
* Object sr 原数组
* int srcPos 从元数据的起始位置开始
* Object dest 目标数组
* int destPos 目标数组的开始起始位置
* int length 要copy的数组长度
*/
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
// 示例size=6，调用add(2, element)方法，则会从index=2+1的位置开始，将数组元素替换为Index起始位置为index=2，长度时6-2=4的数据。
set(int index, E element)
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));
}
indexOf(Object o)
/**
* 根据Object对象获取数组中的索引值
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
get(int index)
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
remove(int index)
/**
* 根据索引删除元素。
* 将该元素后面的元素前移，最后一个元素置空。
*/
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;
}
扫一扫
149
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
