ArrayList核心源码分析

ArrayList核心源码分析

类继承图

ArrayList实现了3个标记接口，RandomAccess、Cloneable、Serializable

• RandomAccess 随机访问(下标访问)，更好的判断集合是ArrayList还是LinkedList，从而选择更好的遍历方式，提高性能
• Cloneable支持克隆机制
• Serializable 通知JVM对类进行序列化

字段分析

• private static final long serialVersionUID = 8683452581122892189L： 序列化版本号(文件签名)，如果不写会默认生成，类内容改变会影响签名变化，导致反序列化失败
• private static final int DEFAULT_CAPACITY = 10：若初始化ArrayList未指定容量大小，则在首次添加时使用该大小作为集合容量
• private static final Object[] EMPTY_ELEMENTDATA = {}
• private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}

以上两个空数组的区别在于区分使用哪种构造方法初始化集合的，方便添加元素时使用扩容策略

• transient Object[] elementData; 集合存储数据用
• private int size 集合的长度

构造方法

   //无参构造方法默认赋予一个空数组
 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_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);
        }
    }
    
 //传入集合转化为ArrayList
public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

add

//默认添加为尾插法
 public boolean add(E e) {
 		//每次添加先判断是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

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

 private static int calculateCapacity(Object[] elementData, int minCapacity) {
 		//如果是无参构造方法初始化的，使用默认容量10作为集合大小
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

private void ensureExplicitCapacity(int minCapacity) {
		//变更数+1(每次操作都会记录变更次数)
        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);
        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时，最好在初始化的时候赋予其初始大小

• 指定下标添加元素

 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位置开始 size-inde长度
    //复制到index+1位置处

最后将index索引处的值替换为要插入的元素即可。

remove

//下标删除
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);
        elementData[--size] = null; // clear to let GC do its work
        //将元素组的下标后一位开始，numMoved长度复制到新数组index处，然后讲数组最后一个元素置为null 交给垃圾收集器回收。
        return oldValue;
    }

迭代器

迭代器属性介绍

private class Itr implements Iterator<E> {
        int cursor;       // 下一个要访问元素下标
        int lastRet = -1; // 上一个元素下标
        int expectedModCount = modCount;
        Itr() {}
}

核心方法

//是否有下一个元素
 public boolean hasNext() {
 		//下一个元素下标!=集合长度则有下一个元素
            return cursor != size;
        } 
        
//获取下一个元素，cursor和lastRet都会做自增操作
 public E next() {
 			//先判断当前集合是否被修改过
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

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

            try {
            //调用集合自己的remove方法
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                //删除操作会将lastRet重置为-1，所以，再调用remvove前应该先调用next()方法
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

• ArrayList迭代器的remove方法使用前要先调用next()方法，否则会抛出IllegalStateException()异常
• 使用迭代器时，不能对集合本身做增删操作否则会抛出ConcurrentModificationException异常

fail-fast

fail-fast机制是java集合中的一种错误机制。
当使用迭代器迭代时，如果发现集合有修改，则快速失败做出响应，抛出ConcurrentModificationException异常。
这种修改有可能是其它线程的修改，也有可能是当前线程自己的修改导致的，比如迭代的过程中直接调用remove()删除元素等。
另外，并不是java中所有的集合都有fail-fast的机制。比如，像最终一致性的ConcurrentHashMap、CopyOnWriterArrayList等都是没有fast-fail的。
fail-fast是怎么实现的：
ArrayList、HashMap中都有一个属性叫modCount，每次对集合的修改这个值都会加1，在遍历前记录这个值到expectedModCount中，遍历中检查两者是否一致，如果出现不一致就说明有修改，则抛出ConcurrentModificationException异常。
底层数组存/取元素效率非常的高(get/set)，时间复杂度是O(1)，而查找（比如：indexOf，contain），插入和删除元素效率不太高，时间复杂度为O(n)。

纯手敲，点滴记录，造就辉煌~加油！