ArrayList构造器
在JDK1.7版本中,ArrayList的无参构造方法并没有生成容量为10的数组;
elementData对象是ArrayList集合底层保存元素的实现;
size属性记录了ArrayList集合中实际元素的个数;
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
//实现Serializable接口,生成的序列版本号:
private static final long serialVersionUID = 8683452581122892189L;
//ArrayList初始容量大小:在无参构造中不使用了
private static final int DEFAULT_CAPACITY = 10;
//空数组对象:初始化中默认赋值给elementData
private static final Object[] EMPTY_ELEMENTDATA = {};
//ArrayList中实际存储元素的数组:
private transient Object[] elementData;
//集合实际存储元素长度:
private int size;
//ArrayList有参构造:容量大小
public ArrayList(int initialCapacity) {
//即父类构造:protected AbstractList() {}空方法
super();
//如果传递的初始容量小于0 ,抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
//初始化数据:创建Object数组
this.elementData = new Object[initialCapacity];
}
//ArrayList无参构造:
public ArrayList() {
//即父类构造:protected AbstractList() {}空方法
super();
//初始化数组:空数组,容量为0
this.elementData = EMPTY_ELEMENTDATA;
}
//ArrayList有参构造:Java集合
public ArrayList(Collection<? extends E> c) {
//将集合转换为数组:
elementData = c.toArray();
//设置数组的长度:
size = elementData.length;
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
}
add()
ArrayList增加元素的方法事关重要,我们都知道ArrayList底层是由数组实现,可以随着元素的增加而扩容,那么具体是如何实现的呢?
在JDK1.7当中,当第一个元素添加时,ensureCapacityInternal()方法会计算ArrayList的扩容大小,默认为10;
其中grow()方法最为重要,如果需要扩容,那么扩容后的大小是原来的1.5倍,实际上最终调用了Arrays.copyOf()方法得以实现;
//添加元素e
public boolean add(E e) {
ensureCapacityInternal(size + 1);
//将对应角标下的元素赋值为e:
elementData[size++] = e;
return true;
}
//得到最小扩容量
private void ensureCapacityInternal(int minCapacity) {
//如果此时ArrayList是空数组,则将最小扩容大小设置为10:
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//判断是否需要扩容:
ensureExplicitCapacity(minCapacity);
}
//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
//操作数+1
modCount++;
//判断最小扩容容量-数组大小是否大于0:
if (minCapacity - elementData.length > 0)
//扩容:
grow(minCapacity);
}
//ArrayList动态扩容的核心方法:
private void grow(int minCapacity) {
//获取现有数组大小:
int oldCapacity = elementData.length;
//位运算,得到新的数组容量大小,为原有的1.5倍:
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新扩容的大小依旧小于传入的容量值,那么将传入的值设为新容器大小:
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新容器大小,大于ArrayList最大长度:
if (newCapacity - MAX_ARRAY_SIZE > 0)
//计算出最大容量值:
newCapacity = hugeCapacity(minCapacity);
//数组复制:
elementData = Arrays.copyOf(elementData, newCapacity);
}
//计算ArrayList最大容量:
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
//如果新的容量大于MAX_ARRAY_SIZE。将会调用hugeCapacity将int的最大值赋给newCapacity:
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
remove()
remove(int index)是针对于角标来进行删除,不需要去遍历整个集合,效率更高;
而remove(Object o)是针对于对象来进行删除,需要遍历整个集合进行equals()方法比对,所以效率较低;
不过,无论是哪种形式的删除,最终都会调用System.arraycopy()方法进行数组复制操作,所以效率都会受到影响;
//在ArrayList的移除index位置的元素
public E remove(int index) {
//检查角标是否合法:不合法抛异常
rangeCheck(index);
//操作数+1:
modCount++;
//获取当前角标的value:
E oldValue = elementData(index);
//获取需要删除元素 到最后一个元素的长度,也就是删除元素后,后续元素移动的个数;
int numMoved = size - index - 1;
//如果移动元素个数大于0 ,也就是说删除的不是最后一个元素:
if (numMoved > 0)
// 将elementData数组index+1位置开始拷贝到elementData从index开始的空间
System.arraycopy(elementData, index+1, elementData, index, numMoved);
//size减1,并将最后一个元素置为null
elementData[--size] = null;
//返回被删除的元素:
return oldValue;
}
//在ArrayList的移除对象为O的元素,不返回被删除的元素:
public boolean remove(Object o) {
//如果o==null,则遍历集合,判断哪个元素为null:
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//快速删除,和前面的remove(index)一样的逻辑
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) {
//操作数+1
modCount++;
//获取需要删除元素 到最后一个元素的长度,也就是删除元素后,后续元素移动的个数;
int numMoved = size - index - 1;
//如果移动元素个数大于0 ,也就是说删除的不是最后一个元素:
if (numMoved > 0)
// 将elementData数组index+1位置开始拷贝到elementData从index开始的空间
System.arraycopy(elementData, index+1, elementData, index, numMoved);
//size减1,并将最后一个元素置为null
elementData[--size] = null;
}
fastRemove()方法对比remove()方法而言,省去了检查角标是否合法的方法rangeCheck(),同时也不需要返回被删除的元素。
set()
由于ArrayList实现了RandomAccess,所以具备了随机访问特性,调用elementData()可以获取到对应元素的值。
//设置index位置的元素值了element,返回该位置的之前的值
public E set(int index, E element) {
//检查index是否合法:判断index是否大于size
rangeCheck(index);
//获取该index原来的元素:
E oldValue = elementData(index);
//替换成新的元素:
elementData[index] = element;
//返回旧的元素:
return oldValue;
}
get()
通过elementData()方法获取对应角标元素,在返回时候进行类型转换;
//获取index位置的元素
public E get(int index) {
//检查index是否合法:
rangeCheck(index);
//获取元素:
return elementData(index);
}
//获取数组index位置的元素:返回时类型转换
E elementData(int index) {
return (E) elementData[index];
}
modCount含义
在Itr迭代器初始化时,将ArrayList的modCount属性的值赋值给了expectedModCount。
通过上面的例子中,我们可以知道当进行增删改时,modCount会随着每一次操作而+1,modCount记录了ArrayList内发生改变的次数。
当迭代器自迭代时,会判断expectedModCount的值是否还与modCount的值保持一致,如果不一致则抛出异常。
transient
transient修饰符是什么含义?
当我们序列化对象时,如果对象中某个属性不进行序列化操作,那么在该属性前添加transient修饰符即可实现。
为什么ArrayList不想对elementData属性进行序列化呢?
ArrayList在添加元素时,可能会对elementData数组进行扩容操作,而扩容后的数组可能并没有全部保存元素。当我们进行序列化时,并不会只序列化其中一个元素,而是将整个数组进行序列化操作,那些没有被元素填充的位置也进行了序列化操作,间接的浪费了磁盘的空间,以及程序的性能。
所以,ArrayList才会在elementData属性前加上transient修饰符。
Arrays.copyOf()
该方法在内部创建了一个新数组,底层实现是调用
System.arraycopy();
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
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;
}
original – 要复制的数组
newLength – 要返回的副本的长度
newType – 要返回的副本的类型
System.arraycopy()
该方法是用了native关键字,调用的为C++编写的底层函数
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
src – 源数组
srcPos – 源数组中的起始位置
dest – 目标数组
destPos – 目标数组中的起始位置
length – 要复制的数组元素的数量