默认容量是10 private static final int DEFAULT_CAPACITY = 10;
用于空实例的共享空数组实例。
private static final Object[] EMPTY_ELEMENTDATA = {};
空数组,无参构造时用来赋值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
数组缓冲区
transient Object[] elementData;
数组长度 private int size;
最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
数组结构修改次数,这是jdk在面对迭代遍历的时候为了避免不确定性而采取的快速失败原则,跟线程安全相关
protected transient int modCount = 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);
}
}
有参就new一个该长度的数组,无参就赋值一个空数组
无参构造
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
直接赋值一个空数组
接下来看add方法
//首先,add的时候不论原来数组长度是多少,都在原基础上+1
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//然后先执行calculateCapacity(elementData,minCapacity)方法,用来确定数组长度
//
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//如果数组是空数组,就返回DEFAULT_CAPACITY(也就是10)作为数组长度
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//list结构修改次数加1
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;//拿到老数组容量
int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量=老容量*1.5
if (newCapacity - minCapacity < 0)//在新容量和之前返回的容量之间取大的
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//新容量比设置的最大长度还大,取Integer的最大值
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
其他常用方法
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;
}
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;
}
lastIndexOf()是从尾部开启遍历的,不是从头开始,记个标识
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;
}
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;
}
先就这样吧