ArrayList的学习

主要的成员变量

//构造函数使用 ArrayList array=new ArrayList(0)的时候将数组赋值为EMPTY_ELEMENTDATA

private static final Object[] EMPTY_ELEMENTDATA = {};

//构造函数使用 ArrayList array=new ArrayList()的时候将数组赋值

//为DEFAULTCAPACITY_EMPTY_ELEMENTDATA

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//存放添加到ArrayList中的元素(底层是使用数组存储)

transient Object[] elementData; // non-private to simplify nested class access

//ArrayList中存储元素的大小

private int size;

主要构造函数

//无参构造函数将elementData 赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA

public ArrayList() {

this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

public ArrayList(int initialCapacity) {

if (initialCapacity > 0) {//大于0直接初始化一个数组大小为initialCapacity

this.elementData = new Object[initialCapacity];

} else if (initialCapacity == 0) {//为0 将elementData 赋值为EMPTY_ELEMENTDATA

this.elementData = EMPTY_ELEMENTDATA;

} else {//小于0抛出异常

throw new IllegalArgumentException("Illegal Capacity: "+

initialCapacity);

}

}

//新增

public boolean add(E e) {

ensureCapacityInternal(size + 1); // 将modCount+1和判断是否需要扩容

elementData[size++] = e;

return true;

}

private void ensureCapacityInternal(int minCapacity) {

//使用的无参构造函数初始化第一次添加的时候将容量设置为默认容量10

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

}

 

ensureExplicitCapacity(minCapacity);

}

private void ensureExplicitCapacity(int minCapacity) {

modCount++; // 将modCount+1

 

// 判断是否需要扩容

if (minCapacity - elementData.length > 0)

grow(minCapacity);

}

//扩容操作

private void grow(int minCapacity) {

// overflow-conscious code

int oldCapacity = elementData.length;

//新的数组容量=老的数组容量+老的数组容量/2 (相当于增大为原来的1.5倍)

int newCapacity = oldCapacity + (oldCapacity >> 1);

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

if (newCapacity - MAX_ARRAY_SIZE > 0)

newCapacity = hugeCapacity(minCapacity);

// 将elementData 中的元素拷贝到大小为newCapacity的新数组中 并将新数组赋值给elementData

elementData = Arrays.copyOf(elementData, newCapacity);

}

//查找元素

public E get(int index) {

rangeCheck(index);//先检查index是否合法

 

return elementData(index);

}

//直接根据数组的下标来查找

E elementData(int index) {

return (E) elementData[index];

}

//根据下标删除元素

public E remove(int index) {

rangeCheck(index);//检查index是否合法

modCount++;//modCount+1

E oldValue = elementData(index);//获取下标为index的元素

//计算index后面还有多少个元素

int numMoved = size - index - 1;

if (numMoved > 0)//如果不是尾元素,将后面的元素整体前移

System.arraycopy(elementData, index+1, elementData, index,

numMoved);

//将最后一个元素设置为null 为了帮助垃圾回收

elementData[--size] = null; // clear to let GC do its work

//返回被删除的元素

return oldValue;

}

//根据对象删除

public boolean remove(Object o) {

if (o == null) { //如果为null就查找第一个为null的元素将其山粗话

for (int index = 0; index < size; index++)

if (elementData[index] == null) {

fastRemove(index);

return true;

}

} else {//非null的话 使用equals来判断是否相等

for (int index = 0; index < size; index++)

if (o.equals(elementData[index])) {

fastRemove(index);

return true;

}

}

return false;

}

 

private void fastRemove(int index) {

modCount++;//modCount+1操作

//计算index后面还有多少个元素

int numMoved = size - index - 1;

if (numMoved > 0)//如果不是尾元素,将后面的元素整体前移

System.arraycopy(elementData, index+1, elementData, index,

numMoved);

//将最后一个元素设置为null 为了帮助垃圾回收

elementData[--size] = null; // clear to let GC do its work

}