public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认的初始容量,在不指定minCapacity变量的时候,它将使用DEFAULT_CAPACITY 作为数组的大小。但是需要注意的是它是在第一次添加元素的时候在使用的,而不是像指定了minCapacity在构造方法中那样在创建ArrayList 的过程中就创建了。
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 指定参数初始容量,但是初始容量是0的时候
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 初始容量是0的数组。无参构造时候,elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA 其实主要是为了区分elementData=它是无参构造的赋值,当有参构造方法但是参数是0的时候的赋值
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 实际存储元素的数组
*/
transient Object[] elementData;
/**
* 实际存储的元素个数,而不是数组的大小
*/
private int size;
}
//ArrayList构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
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);
}
}
public ArrayList(Collection c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
//添加一个元素到列表的末尾
public boolean add(E e) {
ensureCapacityInternal(size + 1);//在添加元素之前要保证数组大小可以容纳该元素
elementData[size++] = e;
return true;
}
//如果是首次添加元素的话,szie=0 则 minCapacity=1
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//计算容量大小
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//如果无参数构造的话,elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA,在第一次添加元素的时候将直接扩容到DEFAULT_CAPACITY,直接返回DEFAULT_CAPACITY默认容量10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
//否则的话则是有参构造或者不是第一次添加元素,那么这里返回的就是size+1,也就是说扩容到所需的szie+1 即可
return minCapacity;
}
//确保足够的容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 当实际需要的最小容量大于数组的容量,不满足要求的容量则进行扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//扩容
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//右移动一位相当于除以2,新的容量大小就相当于原来的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果newCapacity 还是不足的话,直接使用minCapacity作为最小容量
//当无参构造方法创建时第一次调用grow方法minCapacity=10,而newCapacity=0,所以无参构造方法默认的初始容量为10
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//创建一个容量为newCapacity的数组,并把数组elementData元素复制到新的数组里
elementData = Arrays.copyOf(elementData, newCapacity);
}
//容量最大值
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//当超出最大值进行处理
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 void add(int index, E element) {
// 检查位置的合法性
rangeCheckForAdd(index);
//跟add里面的一样,保证数组容量足够
ensureCapacityInternal(size + 1);
// 移动当前位置和其后置的元素
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
// 检查位置的合法性
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
public E set(int index, E element) {
//数组下标是否越界
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
//数组下标是否越界
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
public E get(int index) {
//数组下标是否越界
rangeCheck(index);
return elementData(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);
//通过设置null值让GC起作用
elementData[--size] = null;
return oldValue;
}
//删除ArrayList中的值对象,其实和通过下标删除很相似
//只是多了一个步骤,遍历底层数组elementData,通过equals()方法或 == (特殊情况下)来找到要删除的元素,获取其下标
//最后调用remove(int index)一样的代码即可。
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;
}
//移除
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;
}
ArrayList 还提供了另外一个方法,就是removeIf(),它是一个函数式接口
List cityList = new ArrayList<>(2);
cityList.removeIf((String name )->name.equalsIgnoreCase("Bangalore"));
//移除失败的场景
@Test
public void itratorTest(){
List cityList = new ArrayList<>(4);
cityList.add("重庆");
cityList.add("北京");
cityList.add("上海");
cityList.add("天津");
Iterator itr = cityList.iterator();
while(itr.hasNext()){
String city = itr.next();
if(city.equals("北京")){
cityList.remove(city);
}
System.out.println(city);
}
}
输出结果
重庆
北京
java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
//移除成功的场景
@Test
public void itratorTest2(){
List cityList = new ArrayList<>(4);
cityList.add("重庆");
cityList.add("北京");
cityList.add("上海");
cityList.add("天津");
Iterator itr = cityList.iterator();
while(itr.hasNext()){
String city = itr.next();
if(city.equals("北京")){
itr.remove();
}
System.out.println(city);
}
}
int size() : 获取集合长度,通过定义在ArrayList中的私有变量size得到
boolean isEmpty():是否为空,通过定义在ArrayList中的私有变量size得到
boolean contains(Object o):是否包含某个元素,通过遍历底层数组elementData,通过equals或==进行判断
int lastIndexOf(Object o):返回最后一个元素为o的下标
Object[] toArray():转换成一个新得数组返回
void clear():集合清空,通过遍历底层数组elementData,设置为null