java.util.ArrayList

1. 类定义

//继承了AbstractList类，并且实现了List,RandomAccess,Cloneable和java.io.Serializable接口
public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAccess,Cloneable,java.io.Serializable  

1. 域

//默认容量为10
private static final int DEFAULT_CAPACITY=10;
//一个空的数组实例，用来构造空实例
private static final Object[] EMPTY_ELEMENTDATA={};
//ArrayList的存储数组，如果是空ArrayList，则elementData==EMPTY_ELEMENTDATA
private transient Object[] elementData;
//元素个数
private int size;
//数组的最大存储元素个数
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

1. 构造方法

//初始化一个容量为initialCapacity的ArrayList
public ArrayList(int initialCapacity){
  super();
  if(initialCapacity<0)
   throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
  this.elementData=new Object[initialCapacity];                  
}
//构造一个ArrayList实例，存储数组是空的
public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }
//用一个集合构造一个ArrayList实例
public ArrayList(Collection <? extends E> c){
 elementData = c.toArray();
 size=elementData.length;
 if(elementData.getClass!=Object[].class){
  elementData=Arrays.copayOf(elementData,size,Object[].class);
 }
}

1. 其他方法

//删除ArrayList多余的存储空间（让存储能力刚好等于存储的元素个数）
public void trimToSize(){
modCount++;
if(size < elementData.length){
 elementData = Arrays.copyOf(elmentData,size);
}
}

//确保ArrayList的最小容量，使得能存储所有元素
public ensureCapacity(int minCapacity){
 int minExpand=(elementData!=EMPTY_ELEMENTDATA)?0:DEFAULT_CAPACITY;
 if(minCapacity>minExpand)
  ensureExplicitCapactiy(minCapacity);
}

 private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

//如果minCapacity大于数组容量，则将数组扩充到minCapacity
 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
//ArrayList容量真正扩充是在这个方法里,正常情况下扩充为原数组长度的3/2倍。如果新的长度还是小于minCapacity则，扩充到minCapacity。
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);  //等于最大容量
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
//如果最小容量大于最大数组元素个数，则返回最大整数，否则返回最大数组元素个数
 private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
//返回ArrayList的元素个数
  public int size() {
        return size;
    }
  //判断ArrayList是否为空
 public boolean isEmpty() {
        return size == 0;
    }
  //是否包含o
  public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
  //返回元素o所在位置，从数组头开始遍历，遇到第一个立即返回。给出的o可能为空，所以不能全部用o.equasl，所以要根据o是否为空选择比较方法是==还是用equals,如果没有找到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最后出现的位置
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(elementData[i].equals(o))return i;
}
return -1;
}

public Object clone() {
        try {
            @SuppressWarnings("unchecked")
                ArrayList<E> v = (ArrayList<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

//返回ArryList的数组形式,返回的数组是一个新的数组，元素包含ArrayList的所有元素，但不是ArrayList本身数组的引用。即两个数组没有任何关系
public Object[] toArray(){
 return Arrays.copyOf(elementData,size);
}
//返回一个具体类型的包含ArrayList所有元素的数组
public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }
//返回数组具体位置的元素个数
E elementData(int index) {
        return (E) elementData[index];
    }
 //返回具体位置的元素个数，在返回前先要对输入 的index做合法性判断
public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
//替换指定位置的元素,返回替换之前的元素
public E set(int index, E element){
 rangeCheck(index);
 E oldValue = elementData[index];
 elementData[index]=element;
 return oldValue;
}
//添加一个元素
public boolean add(E e){
 ensureCapacityInternal(size+1);  //这个方法增加了modCount!!!
 elementData[size++]=e;
 return true;
}
//删除指定位置的元素
public E remove(int index){
 rangeCheck(index);
            checkForComodification();
            E result = parent.remove(parentOffset + index);
            this.modCount = parent.modCount;
            this.size--;
            return result;
}