ArrayList

ArrayList

---

概述

ArrayList是List接口的具体实现类，可以存储任何元素，包括null。这个类与Vector类几乎是一样的，仅有的区别就是Vector类是线程安全的(方法有synchronized关键字)，而ArrayList不是。

关于时间复杂度：

• constant time
  
  • size, isEmpty, get, set, iterator, listIterator
• amortized constant time
  
  • add(也就是说，添加n个元素，需要O(n)时间)
• linear time
  
  • other operations

关于线程安全：

• ArrayList不是线程安全的
• 如果多个线程同时访问一个ArrayList实例，并且至少一个线程对ArrayList进行了structural modification(结构化修改，顾名思义，就是修改了结构发生了变化，是说添加或者是删除了一个或多个元素，如果仅仅是修改了元素的值，则不是结构化修改)，那么必须在外部syncronized(使用ArrayList的地方synchronized)。
• 有时候，也会通过以下用法来达到ArrayList的线程安全

List list = Collections.synchronizedList(new ArrayList(...))

关于fast-fail：

ArrayList的iterator()和listIterator()方法返回的iterator，具有fast-fail的特点，也就是说，在iterator创建后，不允许list的结构发生变化(add/remove)，否则会抛出ConcurrentModificationException异常。

---

成员变量

 private static final long serialVersionUID = 8683452581122892189L;
    /* 默认容量 */
    private static final int DEFAULT_CAPACITY = 10;

    /* 所有的空实例共享的空数组 */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 这个空数组是为了与EMPTY_ELEMENTDATA区别开来，后者是当ArrayList
     * 的capacity为0时使用的(比如用来ArrayList(0)这个构造器)，而
     * DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是给有默认长度的空数组使用的
     * 它还可以用来判断容量需要增加多少(见ensureCapacity()方法)
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     /**
      * 这个数组就是ArrayList存储数据的地方啦
      * 它的长度就是数组的capacity。
      * 任何elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA
      * 的ArrayList，当第一个元素添加进来的时候，capacity自动增大为
      * DEFAULT_CAPACITY
      */
    transient Object[] elementData;

    /*List大小，也即当前数组中元素的数目*/
    private int size;

---

构造器

    /**
     * 如果initialCapacity为0，就用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);
        }
    }

    /**
     * 没有指定initialCapacity，就用DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * 这样当第一个数据添加进来的时候，size自动变为DEFAULT_CAPACITY
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 利用一个Collection构造一个ArrayList
     * 先把Collection变为Array
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // 注意这里，如果elementData的类型不是Object，那么用Array.copyOf变为Object
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // size为0，空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

---

成员方法

    /**
     * 把ArrayList的capacity“剪”成size大小，节省空间
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

    /**
     * 增加ArrayList的capacity, 到底能不能增加，还要看情况
     *
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // 如果不相等，那么可以expand任意大小
            ? 0
            // 如果相等，那么说明现在的capacity已经是 DEFAULT_CAPACITY了           
            : DEFAULT_CAPACITY;

        // 如果比需要增大的最小值还小，那么什么都不做
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

    // 内部方法，主要是给add用的
    private void ensureCapacityInternal(int minCapacity) {       
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

        // 防止溢出
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * expand capacity
     */
    private void grow(int minCapacity) {
        // 注意溢出
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); // 每次扩大1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity); // 比最大数组大小还大！！      
        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;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

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

    /**
     * 返回元素在List中第一次出现的索引值，或者是-1(如果没找到)
     * 就算Object为null，也会进行查找~~
     */
    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;
    }

    /**
     * 与indexOf()方向相反
     */
    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;
    }

    /**
     * 返回的是ArrayList的浅拷贝！！☆
     */
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }
    }

    /**
     * 浅拷贝 ☆
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    /**
     * 返回一个包含了本ArrayList所有元素的数组，如果a的长度不小于ArrayList的长度
     * 那么元素就保存在a中，否则，就重新创建一个新的数组，返回...
     */
    @SuppressWarnings("unchecked")
    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;
    }

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[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);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     * 在给定的index处添加元素，那么index后面的元素都要后移，可见效率不高
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    /**
     * 删除给定index处的元素，index后的元素都要前移，效率不高
     */
    public E remove(