ArrayList源码解析

ArrayList源码解析

ArrayList简介：

ArrayList 是list接口的一个常用实现类。它的对象可以认为是一维数组的“类版本”。我们很快就可以看到，ArrayList 对象可以看做是一维数组的改良版本。类似于数组，ArrayList 对象支持元素的随机访问；也就是说，只要给出元素的索引，任何元素的访问时间都是常数。但是同数组不同的是，ArrayList 对象的大小在程序执行的过程中可以自动进行调整，并且ArrayList对象具有在任何索引位置插入和删除对象的方法，而数组如果想要插入和删除对象，则必须要编写代码增加和减少储存空间。

ArrayList方法简介：

首先我们先来看一下ArrayList的所有公共方法。

注：下面方法除构造函数方法外，其他方法皆按照字母顺序排序。

1、public Arraylist()
2、public ArrayList(int initalCapacity)
3、public ArrayList(Collection<? extends E> c)
4、public boolean add(E e)
5、public void add(int index, E element)
6、 public boolean addAll(int index, Collection<? extends E> c)
7、public boolean addAll(Collection<? extends E> c)
8、 public void clear()
9、 public Object clone()
10、 public boolean contains(Object o)
11、public boolean containsAll(Collection<?> c)
12、public void ensureCapacity(int minCapacity)
13、public boolean equals(Object o)
14、 public void forEach(Consumer<? super E> action)
15、public E get(int index)
16、public int hashCode()
17、 public int indexOf(Object o)
18、public boolean isEmpty()
19、public Iterator<E> iterator()
20、public int lastIndexOf(Object o)
21、public ListIterator<E> listIterator()
22、public ListIterator<E> listIterator(int index)
23、public E remove(int index)
24、public boolean remove(Object o)
25、public boolean removeAll(Collection<?> c)
26、public boolean removeIf(Predicate<? super E> filter)
27、 public void replaceAll(UnaryOperator<E> operator)
28、public boolean retainAll(Collection<?> c)
29、public E set(int index, E element)
30、public int size()
31、public void sort(Comparator<? super E> c)
32、public Spliterator<E> spliterator()
33、public List<E> subList(int fromIndex, int toIndex)
34、public Object[] toArray()
35、public <T> T[] toArray(T[] a)
36、public String toString()
37、public void trimToSize()

ArrayList方法解析：

ArrayList类结构关系：

在具体分析Arrayl类的方法之前，我们先看一下ArrayList类的继承关系。

 

从图中可以看出，ArrayList继承AbstractList类，并且实现了List、RandomAccess、Serializable接口。

其中RandomAccess接口为一个空接口，起到一个标识的作用，如果集合类是RandomAccess的实现，则尽量用for(int i = 0; i < size; i++) 来遍历而不要用Iterator迭代器来遍历，在效率上要差一些。反过来，如果List是Sequence List，则最好用迭代器来进行迭代。 其具体细节在我们在这里就不进行讨论了，感兴趣的同学可以自己去查一查。

Serializable是启用序列化功能的接口，这里也不进行讨论了。

AbstractList继承了AbstractCollection.两者都是抽象类，AbstractCollection提供了Collection接口的一些方法的默认实现，AbstractCollection提供了List接口

的默认实现（个别方法为抽象方法）。

ArrayList类的属性：

//默认容量的大小
private static final int DEFAULT_CAPACITY = 10;

//空数组常量
private static final Object[] EMPTY_ELEMENTDATA = {};

//默认的空数组常量
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//存放元素的数组，从这可以发现ArrayList的底层实现就是一个Object数组
transient Object[] elementData;

//数组中包含的元素个数
private int size;

//数组的最大上限
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

ArrayList的属性非常少，一共就只有这五个。其中：DEFAULT_CAPACITY 代表默认容量的大小，在后面我们可以看到，在像ArrayList对象第一次添

加元素的时候，会将ArrayList的容量设置为默认的容量。EMPTY_ELEMENTDATE和DEFAULTCAPACITY_EMPTY_ELEMENTDATA区别不大。这个在后面

讲构造器的时候会详细讲到。其中最重要的莫过于elementData了，ArrayList所有的方法都是建立在elementData之上。

ArrayList构造函数：

ArrayList一共有三个构造函数，分别为：

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);
        }
    }
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    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;
        }
    }

从构造函数我们可以看出，elementDate默认是一个大小为0的的数组，即DEFAULTCAPACITY_EMPTY_ELEMENTDATA，而

当指定数组长度时，elementData的初始大小就变成了我们所指定的初始大小了。如果我们指定数组的默认长度为0时，

elementDate即为EMPTY_ELEMENTDATA,在这里我们还看不出两者的区别，在后面讲到add方法时，就可以看到两者的不同了。

ArrayList同样可以传入一个Collection,当Collection不为空时，复制该Collection。否则elementDate仍然为EMPTY_ELEMENTDATA。

ArrayList的公共方法：

ArrayList的添加方法：

ArrayList添加单个元素有两个方法，分别为：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    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++;
    }

add(E e)方法是用来添加一个单个的元素，其调用了私有方法enesureCapacityInternal(size+1).

  private void ensureCapacityInternal(int 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 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);
    }

我们可以看到，在这个方法中，增加了一个判断，elementData ==DEFAULTCAPACITY_EMPTY_ELEMENTDATA,那么minCapacity=DEFAULT_CAPACITY，也就是等于10.这就区分出了前面所说的DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA的区别。当elemetnDate=DEFAULT_CAPACITY时，第一次添加元素时，容量变为1，而当elementData =DEFAULTCAPACITY_EMPTY_ELEMENTDATA时,第一次添加元素时，容量变为10.

同时，我们也可以看出ArrayList在面对容量不足时，每次扩容都是在原容量的基础上，增加0.5倍。

而add(int index,E e)就比较好理解了，先检查index，然后判断是否需要扩容，需要就扩容，然后将原来的elemetnDate从index起始到最后复制到index+1的位置上，然后在原index位置添加元素。

 ArrayList添加多个元素的方法一样有两个，分别为：

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

 public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

插入多个元素，与插入单个元素的逻辑是一样的，在这里就不再重复了。

ArrayList删除元素方法：

ArrayList删除元素的方法一共有五个，分别是

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

remove(int index)的处理逻辑：先检查index是否大于elementDate的size,如果大于的话，则抛出异常；然后获取elementDate[index],留在方法结束后返回；然后复制素组，从index+1开始，复制size-index-1个元素，复制到elementDate,从index开始；最后设置elementDate[--size]=null；

    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

remove(Object o)的逻辑：先判断Object 是否为null,如果为null,则遍历ArrayList，删除所有的null值，如果有值被删除，则返回true；如果Object不为null，同样遍历ArrayList，删除ArrayList中相同的元素，如果有元素被删除，则返回true.

而fastRemove(int index)的逻辑与remove(int index)，完全一致，只是少了对index的验证。

 public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

 private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

从上面的代码我们可以看出，remove(Collection<?> c)的逻辑：先判断c是否为null，如果为null，则抛出异常。然后遍历elementDate，如果c包含数组elementDate中的元素

，则将该元素添加一次替换原elementDate数组中，最后，将数组的其余位置设为null，如果新数组比原来数组中的元素少，则已经删除了元素，返回true.

除此之外，还有一个清空ArrayList的方法

    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

clear()方法的逻辑：遍历，删除所有元素。

除此之外，还有一个retainAll(collenction<T> c)方法，该方法愿意是取得两个集合得交集，在这里也可以理解为删除集合中不与collection c 重复得元素。

 return batchRemove(c, true); 

可以看到，它得处理逻辑和removeAll是同样得逻辑，这里就不再重复了。

ArrayList修改元素的方法

在JDK1.8之前，修改元素只有一个方法，就是set(int index,Object c).

 public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

逻辑很简单，就是先检查index，然后新元素替换旧元素，并返回旧元素。

在JDK1.8中，添加了一个新方法，批量修改replaceAll(UnaryOperator<E> operator):

public void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            elementData[i] = operator.apply((E) elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

 UnaryOperator<T> extends Function<T, T>，而Function<T,R>方法中有一个抽象方法，R apply<T,t>，方法的原意应该是将一个T转换成R.而这里使用，UnaryOperator,则只能将T转换成T。我们在使用ReplaceAll方法是，必须重写apply方法，作为转换规则。例如：

public class ArrayListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("科比");
        list.add("詹姆斯");
        list.add("库里");
        list.replaceAll(new UnaryOperator<String>() {
            @Override
            public String apply(String t) {
                // TODO Auto-generated method stub
                return t+"牛逼";
            }
        });
        System.out.println(list);
    }
}

输出的结果为：

[科比牛逼, 詹姆斯牛逼, 库里牛逼]

ArrayList查找元素得方法：

 　　

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

        return elementData(index);
    }

get(int index)方法，通过元素的下标来获取元素。其原理就是获取数组的当前下表的元素。

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

 indextOf(Object o)，查找ArrayList是否含有某元素，且返回该元素在集合中的第一个位置的下标。通过遍历元素，获取该集合所含有的第一个该元素的下标。如果不含有该元素，则返回-1.

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

lastIndexOf(Object o)，与indexOf方法想法，该方法查找该元素在集合中最后一个位置，并返回下标。其逻辑与indexOf基本一致，只不过是在遍历的时候选择从后往前遍历。

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

isEmpth（）方法用来查看集合是否为空集合。如果size=0，则为空集合，返回true。否则返回false。

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

　contains(Object o)查看集合中是否含有某元素。其调用indexOf（Object o），如果含有返回ture，否则返回false.

   public int size() {
        return size;
    }

　size()方法用来查看集合中含有多少个元素，返回元素个数。

ArrayList的一些其他常用方法：

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

clone()方法，用来复制集合并返回一个新的集合。而查看copyOf源码，发现最底层是使用native方法进行的复制。我无法确定其到底是深复制还是浅复制。

  private static native Object newArray(Class<?> componentType, int length) throws NegativeArraySizeException; 

所以我写了一个简单的测试代码，代码如下：

public class ArrayListTest{
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<User>();
        list.add(new User("科比"));
        list.add(new User("詹姆斯"));
        list.add(new User("库里"));
        ArrayList list1= (ArrayList) list.clone();
        User user = list.get(1);
        user.name = "麦迪";
        System.out.println(list1);
    }
}

class User{
     String name;
    public User(String name){
        this.name = name;
    }
    @Override
    public String toString() {
        return name;
    }
}

打印结果为：

[科比, 麦迪, 库里]

　　说明ArrayList的复制为潜复制，因为其数组中的元素，并没有进行值复制，而是直接复制了元素的引用。

在Java8中，ArrayList添加了一种新的遍历方法。foreach+lambda表达式遍历。代码如下：

public class ArrayListTest{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("科比");
        list.add("詹姆斯");
        list.add("库里");
        list.forEach((s)->System.out.println(s));
    }
}

因为不懂lambda表达式的实现原理，foreach的源码实在看不懂。等以后研究了lambda表达式的实现原理，在回来研究下foreach方法。

 在Java8中，ArrayList同样新添加了一种排序方法。sort(Comparator<? super E> c).源码如下：

 @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

发现，ArrayList的排序，其实就是调用了数组的排序。我们继续往下看，数组是如何排序的：

    public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                Comparator<? super T> c) {
        if (c == null) {
            sort(a, fromIndex, toIndex);
        } else {
            rangeCheck(a.length, fromIndex, toIndex);
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, fromIndex, toIndex, c);
            else
                TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
        }
    }

    public static void sort(Object[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, fromIndex, toIndex);
        else
            ComparableTimSort.sort(a, fromIndex, toIndex, null, 0, 0);
    }

 private static void legacyMergeSort(Object[] a,
                                        int fromIndex, int toIndex) {
        Object[] aux = copyOfRange(a, fromIndex, toIndex);
        mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
    }

@SuppressWarnings({"unchecked", "rawtypes"})
    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low,
                                  int high,
                                  int off) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

   /** To be removed in a future release. */
    private static <T> void legacyMergeSort(T[] a, int fromIndex, int toIndex,
                                            Comparator<? super T> c) {
        T[] aux = copyOfRange(a, fromIndex, toIndex);
        if (c==null)
            mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
        else
            mergeSort(aux, a, fromIndex, toIndex, -fromIndex, c);
    }

   @SuppressWarnings({"rawtypes", "unchecked"})
    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low, int high, int off,
                                  Comparator c) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off, c);
        mergeSort(dest, src, mid, high, -off, c);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (c.compare(src[mid-1], src[mid]) <= 0) {
           System.arraycopy(src, low, dest, destLow, length);
           return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

可以看出，当比较器为空时，调用了mergeSort（Object[] src,Object[] dest,int low, int high, int off）方法，不为空时，调用了mergeSort（Object[] src,Object[] dest,int low, int high, int off,Comparator c）方法，两个方法基本一模一样，唯一的区别就是在有默认比较器的时候，两个元素的比较实用默认比较器的比较方法来比较。

仔细看两个方法，可以看出，ArrayList.sort方法 时间上是使用了一种优化过后的递归排序，在数组长度小于7的时候使用直接插入排序。数组长度大于7的时候，使用归并排序，直至子数组的长度小于7.

归并排序详见我的另一篇随笔经典排序算法--归并排序。

写在最后：

　　此篇随笔仅用来记录我的学习内容，如有错误，欢迎指正。谢谢！！！