ArrayList底层实现_源码阅读

加油看源码。不会看源码的程序员不是好架构师。

List是一个接口，通过看这个接口我才想起来，接口是可以实现方法的

这是list接口下面的一个方法，我们可以很清楚的看到，他实现了这个方法，但是这个方法是使用default修饰。记住就行

    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

下面看ArrayList

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

默认大小 

private static final int DEFAULT_CAPACITY = 10;

接着往下看。我发现了奇迹。你看为什么他的elementData[] 是一个transient

这个我还是很想知道为什么elementData需要transient修饰？

原因是这个，我们每次对数据序列化的时候，如果序列化elementData数组，那么这个数组可能数据只有1000，而容量却又1500，这样序列化不是浪费很多空间吗？

所以我们防止他那样序列化，我们直接重写readObject()   writeObject()方法。 然后以元素的个数来写入数据。

 

 

构造函数

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

 

 

重点方法切记  indexof, 他是使用equals()方法。这是去比较对象的。

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

 

clone()方法调用的是Arrays.copy(); 

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

 

直接调用System.arraycopy(); 

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

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

        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

        return oldValue;
    }



    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

看一下System.arraycopy（） 这是一个本地方法，使用c语言写的，所以没必要在研究了。

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

 

******************重点方法，扩容，今天被问到了。答得不好*****************  这个方法也是藏的深。

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

说一下Arrays.copyof(); 这个对象就是进行深拷贝。

说一下过程吧： 就是我们每次添加元素的时候，首先会看新增后的容量是不是大于length。如果大于那就进行继续操作，否则扩容。扩容是之前的1.5倍。length + length >> 1;   length>>1 相当于length/2