ArrayList源码分析(二)
ArrayList源码分析(一)
link.
方法
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
注释给出 这个方法可以调整ArrayList的容量为其存储元素的大小,用户可以手动调用该方法。modCount++; 是指对ArrayList的修改次数增加
size < elementData.length,size是当前元素的个数 实际大小,elementData.length是总容量,往往比size大。
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);
}
}
怎么理解呢,意味着,刚创建一个list时 ,minExpand 一定是10,这个时候如果我外部参数minCapacity要求的容量小于10的话 我不会扩充容量,因为我容量够了,否则扩充容量; 而一旦elementData不为空时,我的minExpand 永远为0,这样只要外部参数minCapacity>0就一定执行ensureExplicitCapacity扩充方法进行扩充,至于到底会不会扩充看ensureExplicitCapacity方法的代码。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
所以并不是进入了ensureExplicitCapacity方法就一定扩充,只是有扩充的前提了,但是还有判断外部参数要求的容量minCapacity 是否大于elementData的当前容量,再进行扩充。
核心扩容代码
常量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
很大的一个数
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);
}
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
这是扩容的核心代码,每次扩容为原来的1.5倍,oldCapacity >> 1是右移一位,相当于除以2
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
这个方法没有别的用处,就是对于大数的一个特殊处理。
public int size() {
return size;
}
很简单,直接返回当前list的元素个数
public boolean isEmpty() {
return size == 0;
}
很简单,判断list是否为空
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
很简单,不说了,看看indexOf方法即可
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;
}
indexOf方法没有找到元素时返回的是-1,否则返回的是该元素第一次出现的下标。与之相对的是lastIndexOf方法,返回元素最后一次出现的位置。
equals方法:是Object类的方法,很简单!
public boolean equals(Object obj) {
return (this == obj);
}
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
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);
}
}
注意类必须实现Cloneable接口才可以进行clone,否则报异常CloneNotSupportedException ,这里源码用父类clone一个List对象,然后向下强转成ArrayList类,然后复制即可。内部调用了copyOf方法
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
很简单 内部调用copyOf方法
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
toArray(T[] a)
以正确的顺序返回一个包含此列表中所有元素的数组(从第一个到最后一个元素); 返回的数组的运行时类型是指定数组的运行时类型。
因为要改变类型,内 部肯定是调用的copyOf三个参数的方法 ,arraycopy方法和参数说明如下:
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
@param src the source array.
* @param srcPos starting position in the source array.
* @param dest the destination array.
* @param destPos starting position in the destination data.
* @param length the number of array elements to be copied.