/**
* 修改这个实例的容量,修改这个列表的最大容量为size
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
/**
* 根据传递进来的所需的最小容量判断当前列表是否需要扩容
*/
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// 如果当前列表不是空,那么将最小扩展值置为0
? 0
// 如果当前列表是空,则将最小扩展值置为默认值10
: DEFAULT_CAPACITY;
//比较最小扩展值和最小容量,如果最小容量大于最小扩展值,则需要进行扩容
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
//扩容之前对最小容量进行判断,如果最小容量小于10,则扩展至10
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
*扩容之前判断最小容量是否大于当前列表的最大容量,
*如果最小容量大于当前列表最大容量,则需要扩容
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//当前列表修改次数+1
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* 允许分配的最大的容量(数组)大小,如果过大会导致OutOfMemory异常
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 通过复制当前列表的数组内容到一个新的数组,对当前列表进行扩容
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容大小为当前列表大小的1.5倍
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;//如果扩容1.5倍还是小于最小容量,直接扩容至最小容量
if (newCapacity - MAX_ARRAY_SIZE > 0)//如果需要扩容的值大于MAX_ARRAY_SIZE,取int的最大值进行扩容
newCapacity = hugeCapacity(minCapacity);
// 复制数组,进行扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
/**
*判断需要扩容的值是否大于最大值,是,扩容至int的最大值,否,扩容至MAX_ARRAY_SIZE
*/
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;
}
/**
* 判断当前列表是否为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 判断当前列表是否包含某个对象
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
/**
* 返回列表中o第一次出现的位置,如果没有返回-1
*/
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;
}
/**
* 返回列表中o最后一次出现的位置,如果没有返回-1
*/
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;
}
/**
* 浅度克隆当前列表
*/
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
//如果列表中的对象不支持克隆操作,抛出异常
throw new InternalError(e);
}
}
/**
* 复制一个由当前列表中对象组成的数组并返回
*/
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
/**
* 复制并转换当前列表中的对象为T类型的a数组,如果a数组的长度大于当前列表中对象的数量
* 返回的a数组的size位置置为null
*/
@SuppressWarnings("unchecked")//对过旧的方法不进行提示
public <T> T[] toArray(T[] a) {
if (a.length < size)
//创建一个新的类型的数组
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
/**
* 返回当前数组中index位置的对象
*/
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
/**
* 判断index是否合法,合法则返回当前数组中index位置的对象,不合法则抛出异常
*/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
/**
* 判断index是否合法,合法则将index位置的对象置换为element并返回之前的对象
* 不合法则抛出异常
*/
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
/**
* 在列表的末尾位置增加对象e
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 以当前对象数量+1为最小容量尝试进行扩容
elementData[size++] = e;
return true;
}
/**
* 检查插入对象的位置是否合法,合法则将element插入到index位置,并将
* index位置原来的对象以及之后的对象后移一位,不合法则抛出异常
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // 以当前对象数量+1为最小容量尝试进行扩容
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
/**
* 移除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; // 将末尾位置的对象置为null
return oldValue;
}
/**
* 移除当前列表中和o相等的第一个对象
*/
public boolean remove(Object o) {
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;
}
/*
* 快速移除index位置的对象
*/
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; // 将末尾位置的对象置为null
}
Java源码阅读之ArrayList(2)
最新推荐文章于 2020-10-25 09:41:40 发布