浅谈Java中的ArrayList类

ArrayList就是传说中的动态数组，就是数组的封装实现，它提供了动态的增加和减少元素，灵活的设置数组的大小等好处，主要实现了Collection，Iterable，RandomAccess（修饰接口，表明这个类可以随机访问）等。

ArrayList提供了3种构造方法:

1.可以构造一个指定容量大小的ArrayList对象

    /**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

 

2.构造一个默认大小的ArrayList对象，

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
* DEFAULT_CAPACITY when the first element is added.
*/
private transient Object[] elementData;

当第一次add的时候 如果elementData == EMPTY_ELEMENTDATA，将会最小扩充到DEFAULT_CAPACITY = 10容量的大小

 

3.构造一个包含某个Collection容器中所有对象的ArrayList对象

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    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);
    }

注意

// c.toArray might (incorrectly) not return Object[] (see 6260652)

返回若不是Object[]将调用 Arrays.copyOf方法将其转为Object[],至于6260652应该是对于他们jdk的bug编号.

如下demo：

public class Test {
    public static void main(String[] args) {
        List<Object> l = new ArrayList<Object>(Arrays.asList("foo", "bar"));
        Object[] obj;
        obj = Arrays.asList("foo", "bar").toArray();
        // Arrays.asList("foo", "bar").toArray() produces String[], 
        System.out.println(obj.getClass().getName());//实际是String[]对象
        obj = Arrays.copyOf(obj, obj.length, Object[].class);//转成Object[]对象
        System.out.println(obj.getClass().getName());
        l.set(0, new Object()); // Causes ArrayStoreException
    }
}

 

 

 /**
     * Trims the capacity of this <tt>ArrayList</tt> instance to be the
     * list's current size.  An application can use this operation to minimize
     * the storage of an <tt>ArrayList</tt> instance.
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }

此方法是为了修剪ArrayList的容量，并将modcount+1

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);
    }

ArrayList 一般情况下以1/2倍数为增量，进行增长

 

 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的最大容量为Integer.MAX_VALUE

 

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

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;
    }

这里可以看出ArrayList中可能存在null对象，并且需要我们重写equals方法，如果不重写equals方法，那么默认使用Object的equals

 

 /**
     * Returns a shallow copy of this <tt>ArrayList</tt> instance.  (The
     * elements themselves are not copied.)
     *
     * @return a clone of this <tt>ArrayList</tt> instance
     */
    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();
        }
    }

clone()方法是重写Object对象的clone() 实现了对对象的拷贝，不过ArrayList clone是对ArrayList对象的浅拷贝。

如下demo：

public class Test {
    public static void main(String[] args) {
        ArrayList<StringBuffer> array1 = new ArrayList<StringBuffer>();
        StringBuffer str = new StringBuffer("first");
        array1.add(str);
        ArrayList<StringBuffer> array2 = (ArrayList<StringBuffer>) array1.clone();
        System.out.println(array1);
        System.out.println(array2);
        
        str.append(" second");
        
        System.out.println(array1);
        System.out.println(array2);
    }
//            [first]
//            [first]
//            [first second]
//            [first second]
}

 

注意：ArrayList中频繁出现对modCount字段的操作，是以为迭代器遍历正常。在AbstractList中有如下代码实现：

 final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

防止多线程对ArrayList的修改，影响迭代器遍历操作。