java集合之深入分析ArrayList

ArrayList特点：

ArrayList方法实现：

　　扩容方法的实现：

　　　　源码：

　　　　　　

private void ensureCapacityInternal(int minCapacity) {
        //如果数组为默认大小，则扩大的容量为minCapacity和默认值两个值的较大者
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }        

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

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

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

    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //增加的容量为原来大小的一半
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果增加了一半的容量还比要扩容的数量小，则新数组的大小为要扩容的数量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新数组的大小大于Integer.MAX_VALUE - 8，则进行判断
        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) {
        //如果minCapacity < 0,则容量值溢出
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;//Integer.MAX_VALUE - 8
    }        

　　clone方法分析：

　　　　ArrayList中的clone()方法为浅克隆，克隆后的集合对象与原有的集合对象不是同一个对象（即，指向不同的内存空间），但是它们集合元素引用的对象都是相同的。

　　　　源码：

　　　　　　

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) 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(e);
        }
    }            

　　示例程序：

　　　　

ArrayList<String> list = new ArrayList<>();
                //这样加入集合中时，引用的对象在常量池中
//        list.add("dongfangbubai");
//        String string = "dongfangbubai";
                ////这样加入集合中时，引用的对象堆中
                String string = new String("dongfangbubai");
        list.add(string);
        list.add("shangshanruoshui");
        
        ArrayList listClone = (ArrayList) list.clone();
        System.out.println(listClone);
        
        String content = "dongfangbubai";
        
        System.out.println(list.get(0).equals(content));
        System.out.println(list.get(0) == content);
//克隆前后两个集合对应的元素所引用的都是同一个对象，true
                System.out.println(list.get(0) == listClone.get(0));
        //克隆前后两个集合是不同的集合，false
        System.out.println(list == listClone);                                            

　　ArrayList迭代时用迭代器只能一次删除一个元素（在一个迭代循环里），否则会出现java.lang.IllegalStateException异常。从源码可以看出这一点。

　　

public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);

                cursor = lastRet;
//进行一次删除操作时，随即就把lastRet置为一，每次迭代时就把迭代的元素索引赋个给astRet
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

 

　　

// 数据结构发生改变，和fail-fast机制有关，在使用迭代器过程中，只能通过迭代器的方法（比如迭代器中add，remove等），修改List的数据结构， // 如果使用List的方法（比如List中的add，remove等），修改List的数据结构，会抛出ConcurrentModificationException

 　　

fail-fast机制的实现

　　

fail-fast机制也叫作”快速失败”机制，是java集合中的一种错误检测机制。

在对集合进行迭代过程中，除了迭代器可以对集合进行数据结构上进行修改（迭代器进行结构修改时不会增加modCount值），其他的对集合的数据结构进行修改，都会抛出ConcurrentModificationException错误。

这里，所谓的进行数据结构上进行修改,是指对存储的对象，进行add,set,remove操作，进而对数据发生改变。

ArrayList中，有个modCount的变量，每次进行add，set，remove等操作，都会执行modCount++。

在获取ArrayList的迭代器时，会将ArrayList中的modCount保存在迭代中，

每次执行add,set,remove等操作，都会执行一次检查，调用checkForComodification方法，对modCount进行比较。

如果迭代器中的modCount和List中的modCount不同，则抛出ConcurrentModificationException

　源码：源码中modCount在list中，

expectedModCount是在迭代时传入的modCount值，若迭代过程中list结构改变时，modCount会增加，以此迭代器1来判断迭代时list是否变化。

　　

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

ArrayList与vector比较：