JDK ArrayList源码学习

ArrayList类的声明部分 实现的借口 继承了AbstractList类

 

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

 

注意 ArrayList不是线程安全的！！！Vector是

 

private transient Object[] elementData

用数组保存内容 数组是Object类型 

用transient声明一个实例变量，当对象存储时，它的值不需要维持

 

public ArrayList() {
    this(10);
} 

默认构造器 默认的size是10

 

另外两个构造器

public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
}

 

 public ArrayList(Collection<? extends E> c) {
     elementData = c.toArray();
     size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
     if (elementData.getClass() != Object[].class)
             elementData = Arrays.copyOf(elementData, size, Object[].class);

}

 

 

类里面的一些方法

 public boolean contains(Object o) {
     return indexOf(o) >= 0;
}

 

public int indexOf(Object o) {
 if (o == null) {                                          //可见 ArrayList可以存放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;
}

 

 

public E set(int index, E element) {
     RangeCheck(index);

     E oldValue = (E) elementData[index];
     elementData[index] = element;
     return oldValue;                                      //   oldValue 注意这个函数的返回值
}

 

 

 public boolean add(E e) {
     ensureCapacity(size + 1);  // Increments modCount!!
     elementData[size++] = e;
     return true;
}

 

 

 public void ensureCapacity(int minCapacity) { //这个方法很重要动态增长数组  当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。 

     modCount++;
     int oldCapacity = elementData.length;
     if (minCapacity > oldCapacity) {
         Object oldData[] = elementData;
         int newCapacity = (oldCapacity * 3)/2 + 1;    // 增加1.5 倍    扩容
         if (newCapacity < minCapacity)
              newCapacity = minCapacity;                  //至少要扩容到  minCapacity
            // minCapacity is usually close to size, so this is a win:
         elementData = Arrays.copyOf(elementData, newCapacity);
    }
}


public void add(int index, E element) {
   if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
           "Index: "+index+", Size: "+size);

    ensureCapacity(size+1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1, size - index);  // System.arraycopy 是一个native方法
    elementData[index] = element;
    size++;
}

 

public E remove(int index) {
    RangeCheck(index);

    modCount++;
    E oldValue = (E) elementData[index];

    int numMoved = size - index - 1;
    if (numMoved > 0)
         System.arraycopy(elementData, index+1, elementData, index,  numMoved);    //将index之后的元素依次向前移动
    elementData[--size] = null; // Let gc do its work      让最后一个位置 置成null 好回收

    return oldValue;
}

 

 

public boolean remove(Object o) {
      if (o == null) {
            for (int index = 0; index < size; index++)
      if (elementData[index] == null) {
           fastRemove(index);  //fastRemove  与 remove 的区别就是fastRemove返回类型是void 而且不用进行范围检查
          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; // Let gc do its work
}

 

 

 protected void removeRange(int fromIndex, int toIndex) {// 先整体移动向前，然后把后面的置null
       modCount++;
       int numMoved = size - toIndex;
       System.arraycopy(elementData, toIndex, elementData, fromIndex,
                              numMoved);

        // Let gc do its work
      int newSize = size - (toIndex-fromIndex);
      while (size != newSize)
           elementData[--size] = null;
}

 

 public boolean addAll(Collection<? extends E> c) {


        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacity(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
}

 

public boolean addAll(int index, Collection<? extends E> c) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
     "Index: " + index + ", Size: " + size);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacity(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
          System.arraycopy(elementData, index, elementData, index + numNew, numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}