Java ArrayList使用总结

private int size; // 实际元素个数
transient Object[] elementData; //真正保存元素的数组
private static final int DEFAULT_CAPACITY = 10;//默认的初始容量大小

//1、无参数直接初始化，数组大小为空
public ArrayList() {
 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//2、指定初始数据初始化
public ArrayList(Collection<? extends E> c){
 //elementData是保存数组的容器，默认为null
 elementData=c.toArray();
 //如果给定的集合（c)数据有值
 if((size=elementData.length)!=0){
  	//c.toArray might(incorrectly)not return Object[](see 6260652)
  	//如果集合元素类型不是Object类型，我们会转成Object
	 if(elementData.getClass()!=Object[].class){
	  elementData=Arrays.copyOf(elementData,size,Object].class);
	 }
 	}else{
 	//给定集合（c)无值，则默认空数组
 	this.elementData=EMPTY_ELEMENTDATA
 	}
}
//3、指定初始容量
public ArrayList(int initialCapacity) {
	//指定的初始容量大于0，将elementData初始化为指定大小的数组
 if (initialCapacity > 0) {
  this.elementData = new Object[initialCapacity];
 } else if (initialCapacity == 0) {
 	//否则初始化成一个空数组
  this.elementData = EMPTY_ELEMENTDATA;
 }
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final Object[] EMPTY_ELEMENTDATA = {};

public boolean add(E e) {
	//确保数组大小是否足够，不够执行扩容，size为当前数组元素个数，判断size+1是因为后面还要size++
 ensureCapacityInternal(size + 1); //1
 elementData[size++] = e;//2
 return true;
}

private void ensureCapacityInternal(int minCapacity) {
	//先调用calculateCapacity计算容量
 	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
 //如果当前数组还是个空数组，也就是他用过无参构造去初始化的
 //那么直接返回DEFAULT_CAPACITY，即10
 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  return Math.max(DEFAULT_CAPACITY, minCapacity);
 }
 return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
 modCount++;

 // 如果当前容量已经大于当前数组的长度了，说明需要去扩容了
 if (minCapacity - elementData.length > 0)
  //扩容
  grow(minCapacity);
}

private void grow(int minCapacity){
 int oldCapacity = elementData.length;
 //oldCapacity>>1是把oldCapacity除以2的意思
 int newCapacity=oldCapacity+(oldCapacity>>1);
 //如果扩容后的值<我们的期望值，扩容后的值就等于我们的期望值
 if(newCapacity-minCapacity<0)
 newCapacity = minCapacity;
 //如果扩容后的值>jvm所能分配的数组的最大值，那么就用Integer的最大值
 if(newCapacity-MAX_ARRAY_SIZE>0)
 elementData=Arrays.copyOf(elementData,newCapacity);
}

/**
*@param src 被拷贝的数组
*@param srcPos 从数组那里开始
*@param dest 目标数组
*@param destPos从目标数组那个索引位置开始拷贝
*@param length 拷贝的长度
*此方法是没有返回值的，通过dest的引用进行传值
*/
public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);

public boolean remove(Object o) {
 //如果要删除的值是null,删除第一个是null的值
 if(o==null){
 for(int index=0;index<size;index++)
  if(elementData[index]==null){
  fastRemove(index)
  return true;
  }
 }else{
 //如果要删除的值不为null,找到第一个和要删除的值相等的删除
 for(int index=0;index<size;index++)
  //这里是根据 equals来判断值相等的，相等后再根据索引位置进行删除
  //所以根据对象删除时，一般来说，如果你确定要删除的是某一类的业务对象，则需要重写equals
  if(o.equals(elementData[index]){
  fastRemove(index)
  return true;
  }
 }
 return false
}

private void fastRemove(int index){
 //记录数组的结构要发生变动了
 nodCount++;
 //numMoved表示删除index位置的元素后，需要从index后移动多少个元素到前面去
 //减1的原因，是因为size从1开始算起，index从0开始算起
 int numMoved=size-index-1;
 if(numMoved>0)
 //从index+1位置开始被拷贝，拷贝的起始位置是index,长度是numMoved
 System.arraycopy(elementData, index+1, elementData, index, numMoved);
 //数组最后一个位置赋值null,帮助GC(没有引用则自动回收了)
 elementData[--size] = null;
}