ArrayList常用方法源码

源码：基于JDK1.8

成员变量：

　　//序列化的版本
　　private static final long serialVersionUID = 8683452581122892189L;
　　//默认初始化大小
    private static final int DEFAULT_CAPACITY = 10;
　　//全局常量：空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
　　//默认容量
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
　　//Object数组，我们操作ArrayList，实际上就是操作这个数组
    transient Object[] elementData; // non-private to simplify nested class access
　　//数组的大小
    private int size;

构造函数：

    //参数为容器容量
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {//初始化容量大于0
            this.elementData = new Object[initialCapacity];//就初始化elementData
        } else if (initialCapacity == 0) {//如果等于0
            this.elementData = EMPTY_ELEMENTDATA;//赋值为默认空数组
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);//不合法容量异常
        }
    }

  　　//参数为一个集合
  　　public ArrayList(Collection<? extends E> c) {
          elementData = c.toArray();//转换成数组
          if ((size = elementData.length) != 0) {//如果数组非空
              if (elementData.getClass() != Object[].class)//如果数组的类不是Object类
                  elementData = Arrays.copyOf(elementData, size, Object[].class);//则转成Object类的数组。
          } else {
              this.elementData = EMPTY_ELEMENTDATA;//默认空数组
          }
      }
      //无参构造
      public ArrayList() {
          this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//默认是空数组
      }

(1)常用的add(element)方法：

    public boolean add(E e) {
            //确认是否要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;//在数组的最后增加元素
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    /**
     * 计算容器容量：当前数组为空数组时，返回默认数组长度为10，否则原封不动地返回minCapacity
     * @param elementData 当前数组
     * @param minCapacity 当前数组size+1后的值
     * @return 新的容量
     */


    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//如果是空数组
            return Math.max(DEFAULT_CAPACITY, minCapacity);//则返回默认容器容量
        }
        return minCapacity;//否则直接返回容器容量
    }

    /**
     * 明确是否要扩容
     * @param minCapacity
     */
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//如果计算出来的容量比当前的数组长度要大
            grow(minCapacity);//则要扩容
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新数组的容量是 旧数组的长度+旧数组的长度/2
        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) 
            throw new OutOfMemoryError();
        //如果不是内存溢出，判断计算出来的容量是否大于阈值，如果大于阈值，则返回最大整型，否则返回阈值。
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

(2)add(index, element):检查index是否越界，确认是否要扩张数组（如果需要扩张就扩张），从index开始，向后移动size-index位，将index位置的元素值设置为elment，数组长度加1.

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);//从index开始，向后移动size-index位
        elementData[index] = element;
        size++;
    }
    /**
     * 检查index是否越界
     * @param index
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    
    /**
     * 将src数组从srcPos开始拷贝length个元素复制到dest数组中
     * 其中dest数组从destPos开始粘贴，粘贴length个元素
     * @param src 原数组
     * @param srcPos    原数组的起始位置
     * @param dest 目标数组
     * @param destPos 目标数组的起始位置
     * @param length 要拷贝的长度
     */
    public static native void arraycopy(Object src,  int  srcPos,
            Object dest, int destPos,
            int length);

 

(3)remove(index)：检查要删除的下标是否合理，将要删除的元素取出来，然后计算需要移动的位数并且移动，数组长度减1，将最后一个元素置成空，等待gc。

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

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

        int numMoved = size - index - 1;//计算需要向前移动元素多少位
        if (numMoved > 0)//如果移动位数大于0
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);//从index+1开始，向前移动numMoved位
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }
   @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

 

(4)remove(object):遍历数组，找到需要删除元素的下标，然后计算需要移动的位数并且移动，数组长度减1，将最后一个元素置成空，等待gc。

    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; // clear to let GC do its work
    }