ArrayList实现原理（JDK1.8）

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

ArrayList 继承于AbstractList，实现了List接口，其实AbstractList 已经实现过List接口，这里重复实现使得接口功能更加清晰，JDK中很多类都是如此。

其中Cloneable接口是克隆标记接口，Serializable序列化标记接口，需要clone和序列化功能必须实现这两个接口，而RandomAccess，单纯是一个标志接口 ，该接口表示该类支持快速随机访问，且在循环遍历时for循环的方式会优于用迭代器。

1.成员变量

  1.  	// 默认初始容量
  2.    private static final int DEFAULT_CAPACITY = 10;
  4.    // 空数组实例，初始容量为0或者传入集合为空集合（不是null）时使用
  5.    private static final Object[] EMPTY_ELEMENTDATA = {};
  7.    // 空数组示例，无参构造时使用
  8.    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  10.    // ArrayList内部数据容器
  11.    transient Object[] elementData; // non-private to simplify nested class access
  13.    // 实际元素数量
  14.    private int size;

在ArrayList中，主要有五个成员变量。DEFAULT_CAPACITY表示初始容量大小，即在我们初始化ArrayList时不指定容量大小， 默认容量将会是10，Object[] elementData 则是ArrayList内部实际存储对象的容易，也就是我们常说的ArrayList是数组实现的。

在1.8中，空数组分为了两类情况，EMPTY_ELEMENTDATA 与 DEFAULTCAPACITY_EMPTY_ELEMENTDATA，在标记空数组的时候区分了不同的情况。

2.构造方法

ArrayList有三个构造方法，指定容量的ArrayList(int initialCapacity) ，无参构造ArrayList() 以及传入集合的ArrayList(Collection<? extends E> c)。

  1.     public ArrayList() {
  2.         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  3.     }

最简单的莫过于无参构造，直接赋值为空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA。其实对于常说的默认容量10，是在第一次添加元素调用add()方法时处理的，并不是构造方法中。

  1.     public ArrayList(int initialCapacity) {
  2.         if (initialCapacity > 0) {
  3.             this.elementData = new Object[initialCapacity];
  4.         } else if (initialCapacity == 0) {
  5.             this.elementData = EMPTY_ELEMENTDATA;
  6.         } else {
  7.             throw new IllegalArgumentException("Illegal Capacity: "+
  8.                     initialCapacity);
  9.         }
  10.     }

对于传入容量的构造方法，当传入参数 > 0时，直接初始化对应容量的数组，参数类型为int，也即ArrayList的最大初始容量不能超过Integer.MAX_VALUE，事实上ArrayList的最大容量也只能是Integer.MAX_VALUE。而初始容量传入0，会赋值为空数组EMPTY_ELEMENTDATA。如果 < 0，这个显然的不允许了，直接IllegalArgumentException

  1.     public ArrayList(Collection<? extends E> c) {
  2.         elementData = c.toArray();
  3.         if ((size = elementData.length) != 0) {
  4.             // c.toArray might (incorrectly) not return Object[] (see 6260652)
  5.             if (elementData.getClass() != Object[].class)
  6.                 elementData = Arrays.copyOf(elementData, size, Object[].class);
  7.         } else {
  8.             // replace with empty array.
  9.             this.elementData = EMPTY_ELEMENTDATA;
  10.         }
  11.     }

集合构造时，没有进行null校验，也就是说如果传入null，直接就会NPE异常。集合构造的逻辑也很简单，当传入集合不为空时，调用Arrays.copyOf进行复制，并且容量 size为传入大小，而传入集合为空，则赋值为空数组EMPTY_ELEMENTDATA。

3.添加元素

ArrayList在添加元素时，都会进行容量确认，可能会涉及到扩容，数组复制，所以效率相对较低。同时在添加元素时，ArrayList并未对元素本身进行校验，所以是允许集合中存在null的情况。

3.1.尾部添加元素
  1.     public boolean add(E e) {
  2.         // 确定容量
  3.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  4.         // 设值
  5.         elementData[size++] = e;
  6.         return true;
  7.     }

在add()方法中，最主要的是确定容量ensureCapacityInternal(int minCapacity)方法。

  1.     private void ensureCapacityInternal(int minCapacity) {
  2.         ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
  3.     }

首先会调用calculateCapacity(Object[] elementData, int minCapacity) 计算容量然后再ensureExplicitCapacity(int minCapacity)

  1.     private static int calculateCapacity(Object[] elementData, int minCapacity) {
  2.         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  3.             return Math.max(DEFAULT_CAPACITY, minCapacity);
  4.         }
  5.         return minCapacity;
  6.     }

这里仅仅判断了是否是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA（== 地址比较），如果前面还有印象的话，这个只会在无参构造时，才会初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，这时候会取DEFAULT_CAPACITY（10）与传入minCapacity的较大值，常说的默认容量大小10也就是在这里诞生的。

而其他的情况，都直接但会minCapacity，也即 size + 1，如果首次添加，那就是1。

  1.     private void ensureExplicitCapacity(int minCapacity) {
  2.         modCount++;
  3.         // overflow-conscious code
  4.         if (minCapacity - elementData.length > 0)
  5.             grow(minCapacity);
  6.     }

modCount是一个操作计数器，add与remove都会 + 1。当我们需要在循环中删除ArrayList元素时，需要使用迭代器Iterator的remove()方法，此时直接使用List的删除有针对modCount的校验，会抛出 ConcurrentModificationException异常。

如果minCapacity大于数组容量，则调用grow(int minCapacity)进行扩容。

  1.     private void grow(int minCapacity) {
  2.         // overflow-conscious code
  3.         int oldCapacity = elementData.length;
  4.         // 新容量增长 0.5倍
  5.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  6.         if (newCapacity - minCapacity < 0)
  7.             newCapacity = minCapacity;
  8.         if (newCapacity - MAX_ARRAY_SIZE > 0) // MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
  9.             newCapacity = hugeCapacity(minCapacity);
  10.         // minCapacity is usually close to size, so this is a win:
  11.         elementData = Arrays.copyOf(elementData, newCapacity);
  12.     }

扩容时，新的容量为原容量 + 原容量的一半，也就是0.5倍增长。如果增长后的新容量比计算出来的容量minCapacity小，则赋值为minCapacity，如果大于MAX_ARRAY_SIZE(Integer.MAX_VALUE - 8)，则进入hugeCapacity(int minCapacity)方法。

  1.     private static int hugeCapacity(int minCapacity) {
  2.         if (minCapacity < 0) // overflow
  3.             throw new OutOfMemoryError();
  4.         return (minCapacity > MAX_ARRAY_SIZE) ?
  5.             Integer.MAX_VALUE :
  6.             MAX_ARRAY_SIZE;
  7.     }

这里可以看到，当minCapacity < 0 时，会产生OutOfMemoryError，这是一个Error子类，这是需要避免的。什么时候minCapacity会小于0呢，当ArrayList大小为Integer.MAX_VALUE后，还需要扩容，则会发生错误。

这个方法，我们可以看出，当ArrayList需要的容量首次大于MAX_ARRAY_SIZE时，会设置为MAX_ARRAY_SIZE，然后再次扩容时会变成Integer.MAX_VALUE，如果还不够，那就会发生错误。

扩容的最后一步是调用Arrays.copyOf进行元素的复制，这个最终也是调用System.arraycopy进行操作的。同时size++，实际元素的数量也增加 1。

3.2.中间添加元素
  1.     public void add(int index, E element) {
  2.         rangeCheckForAdd(index);
  3. 		// 确认容量大小
  4.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  5.         System.arraycopy(elementData, index, elementData, index + 1, size - index);
  6.         elementData[index] = element;
  7.         size++;
  8.     }

在中间添加元素的逻辑和尾部添加元素基本一样。

  1.     private void rangeCheckForAdd(int index) {
  2.         if (index > size || index < 0)
  3.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  4.     }

添加元素前，首先要进行范围检查，添加的范围只能在[0，size]之间，index == size时，其实就是尾部插入。然后确认容量新的容量，这个方法尾部添加时已经讲过，接着数组复制，这步复制会跳过index位置的处理，最后再对index位置赋值，即完成了index位置的添加。

可以看到最后调用了size++，add(int index, E element)方法总是会添加元素，即使该index位置存在数据，只是会将原来的index位置数据往后挤动一位，并不会进行覆盖。

3.3.批量添加

ArrayList除了add()与add(int index, E element)，还有两个批量添加的方法。

  1.     public boolean addAll(Collection<? extends E> c) {
  2.         Object[] a = c.toArray();
  3.         int numNew = a.length;
  4.         // 确认容量
  5.         ensureCapacityInternal(size + numNew);  // Increments modCount
  6.         System.arraycopy(a, 0, elementData, size, numNew);
  7.         size += numNew;
  8.         return numNew != 0;
  9.     }
  11.     public boolean addAll(int index, Collection<? extends E> c) {
  12.         // 范围检查
  13.         rangeCheckForAdd(index);
  14.         Object[] a = c.toArray();
  15.         int numNew = a.length;
  16.         // 确认容量
  17.         ensureCapacityInternal(size + numNew);  // Increments modCount
  18.         int numMoved = size - index;
  19.         if (numMoved > 0)
  20.             System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
  21.         System.arraycopy(a, 0, elementData, index, numNew);
  22.         size += numNew;
  23.         return numNew != 0;
  24.     }

有了前面单个元素的添加基础，批量添加就很好懂了，唯一的区别就是在数组复制时，是复制整个待添加的集合。对于index位置的批量添加，中间插入的话（numMoved > 0），第一次复制会腾出中间要添加集合长度的位置，第二次将添加的集合复制到index位置。

4.修改元素

对于ArrayList中元素的修改，如果是对象属性的修改，可以直接修改引用对象，但对于基本类型包装类或者String呢，并没有办法通过引用修改，亦或者我们要更换对象引用，这时候就需要调用set(int index, E element)。

  1.     public E set(int index, E element) {
  2.         // 范围检查
  3.         rangeCheck(index);
  4.         E oldValue = elementData(index);
  5.         elementData[index] = element;
  6.         return oldValue;
  7.     }

这个方法实现很容易，ArrayList的修改本质就是对数组的值进行更改。首先进行范围检查，防止数组越界，这个很好理解，ArrayList内部就是数组，然后对index位置的值进行替换即可。

  1.     private void rangeCheck(int index) {
  2.         if (index >= size)
  3.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  4.     }

elementData(int index)获取了原来的值，用于set返回值，elementData实现更加简单，就是数组取值。

5.移除元素

ArrayList中移除元素的方法有三个，按索引删除remove(int index)、按元素删除remove(Object o)以及批量删除removeAll(Collection<?> c)等。

5.1.索引删除
  1.     public E remove(int index) {
  2.         // 范围检查
  3.         rangeCheck(index);
  4.         modCount++;
  5.         E oldValue = elementData(index);
  6.         int numMoved = size - index - 1;
  7.         // 是否删除的最尾部
  8.         if (numMoved > 0)
  9.             System.arraycopy(elementData, index+1, elementData, index, numMoved);
  10.         elementData[--size] = null; // clear to let GC do its work
  11.         return oldValue;
  12.     }

由于移除元素，并不涉及内部数组大小变化，所以实现相对较简单。必须要的范围检查，这个已经丝毫不陌生了，然后判断是否是尾部删除，如果不是尾部删除，则进行System.arraycopy复制，复制的目的是将index后的元素向前挪动 1 位元素以覆盖要删除的index位置，然后size减 1。

在移除方法中，可以看到modCount进行增加。同时对移除后尾部的元素赋值为null了，让GC生效。

5.2.按元素删除
  1.     public boolean remove(Object o) {
  2.         if (o == null) {
  3.             for (int index = 0; index < size; index++)
  4.                 if (elementData[index] == null) {
  5.                     fastRemove(index);
  6.                     return true;
  7.                 }
  8.         } else {
  9.             for (int index = 0; index < size; index++)
  10.                 if (o.equals(elementData[index])) {
  11.                     fastRemove(index);
  12.                     return true;
  13.                 }
  14.         }
  15.         return false;
  16.     }

按元素删除的时候，首先判断了元素是否为null，因为ArrayList中是可以添加null的，这里不同分支的逻辑是一样的，都是遍历集合比较是否和传入元素相同，只是比较一个是 == null 一个是 equals。如果相同则删除，然后return了，所以remove(Object o)方法只会删除集合第一个与传入对象相同的元素。

重点就是这个fastRemove了。

  1.     private void fastRemove(int index) {
  2.         modCount++;
  3.         int numMoved = size - index - 1;
  4.         if (numMoved > 0)
  5.             System.arraycopy(elementData, index+1, elementData, index, numMoved);
  6.         elementData[--size] = null; // clear to let GC do its work
  7.     }

看到这个方法第一感觉是什么？是不是似曾相识，没错，fastRemove和按指针删除基本上市一样的，只是少了范围校验和获取删除前的元素这两步。

5.3.批量删除
  1.     public boolean removeAll(Collection<?> c) {
  2.         Objects.requireNonNull(c);
  3.         return batchRemove(c, false);
  4.     }

对于removeAll(Collection< ? > c)，校验非空后调用了batchRemove(Collection< ? > c, boolean complement)。

  1.     private boolean batchRemove(Collection<?> c, boolean complement) {
  2.         final Object[] elementData = this.elementData;
  3.         int r = 0, w = 0;
  4.         boolean modified = false;
  5.         try {
  6.             for (; r < size; r++)
  7.                 // 找出不需要移除的元素，放在数组的前面
  8.                 if (c.contains(elementData[r]) == complement)
  9.                     elementData[w++] = elementData[r];
  10.         } finally {
  11.             // Preserve behavioral compatibility with AbstractCollection,
  12.             // even if c.contains() throws.
  13.             if (r != size) {
  14.                 System.arraycopy(elementData, r, elementData, w, size - r);
  15.                 w += size - r;
  16.             }
  17.             if (w != size) {
  18.                 // clear to let GC do its work
  19.                 for (int i = w; i < size; i++)
  20.                     elementData[i] = null;
  21.                 modCount += size - w;
  22.                 size = w;
  23.                 modified = true;
  24.             }
  25.         }
  26.         return modified;
  27.     }

这个方法看着可能有一点点绕，但明白其原理后就很清晰了，首先遍历数组，找出在要移除数组中不包含的元素，从原数组头部开始放，这样的数有w个，即最终数组前w个元素都是在集合c中包含的，而剩下的位置的元素则不关心，最后就是讲w到size的元素赋值为null，以便GC工作。

6.循环删除

前面也提到了，ArrayList在循环删除时会报错，这个究竟是怎么回事呢？

如果我们想删除一个集合中全部的某一个元素，例如下面集合ss中的a元素。

  1.         List<String> ss = new ArrayList<>();
  2.         ss.add("a");
  3.         ss.add("b");
  4.         ss.add("a");
  5.         ss.add("b");
  6.         ss.add("c");

当我们需要删除一个时，我们可以调用remove方法删除，根据索引或者根据元素都用，但是多个时，我们不知道每一个元素的索引，而根据值也不知道有多少个a存在，所以我们需要遍历集合。

这时候就可能存在问题了。

  1.         for (String s : ss) {
  2.             if("a".equals(s)){
  3.                 ss.remove(s);
  4.             }
  5.         }

无论是fori的还是foreach的删除，都会抛出java.util.ConcurrentModificationException，这是因为Arraylist循环时每一次取值都会调用其内部类Itr.next()方法。

  1.         public E next() {
  2.             // 校验modCount
  3.             checkForComodification();
  4.             int i = cursor;
  5.             if (i >= size)
  6.                 throw new NoSuchElementException();
  7.             Object[] elementData = ArrayList.this.elementData;
  8.             if (i >= elementData.length)
  9.                 throw new ConcurrentModificationException();
  10.             cursor = i + 1;
  11.             return (E) elementData[lastRet = i];
  12.         }

在该方法最开始的地方，有校验modCount的checkForComodification()方法，这个方法中比较了modCount和expectedModCount，不相等就会抛出ConcurrentModificationException异常。

  1.         final void checkForComodification() {
  2.             if (modCount != expectedModCount)
  3.                 throw new ConcurrentModificationException();
  4.         }

那expectedModCount到底是什么，为什么和modCount不相等呢。

  1.     private class Itr implements Iterator<E> {
  2.         int cursor;       // index of next element to return
  3.         int lastRet = -1; // index of last element returned; -1 if no such
  4.         int expectedModCount = modCount;

expectedModCount是Itr的成员变量，这个在进行循环时会初始化赋值为modCount，最开始的时候他们是相等的，经过前面的探究，我们已经知道在remove调用时modCount会自增，所以checkForComodification就会抛出异常。

而我们常使用的这个做法就是使用 Itr 的remove。

  1.         Iterator<String> it = ss.iterator();
  2.         while (it.hasNext()){
  3.             if("a".equals(it.next())){
  4.                 it.remove();
  5.             }
  6.         }

这样删除时就没有任何问题了，这是因为 Itr 的remove中，对expectedModCount进行了重新赋值，使得每一次调用后值都相等。

  1.         public void remove() {
  2.             if (lastRet < 0)
  3.                 throw new IllegalStateException();
  4.             checkForComodification();
  5.             try {
  6.                 // 调用ArrayList的删除
  7.                 ArrayList.this.remove(lastRet);
  8.                 cursor = lastRet;
  9.                 lastRet = -1;
  10.                 // expectedModCount重新赋值
  11.                 expectedModCount = modCount;
  12.             } catch (IndexOutOfBoundsException ex) {
  13.                 throw new ConcurrentModificationException();
  14.             }
  15.         }

7.其他方法

ArrayList中主要的就是构造方法、add和remove了，这几个方法看懂后，其他方法实现就比较清晰了。

比如get方法，其实就是根据索引获取了数组的元素。

  1.     public E get(int index) {
  2.         // 范围检查
  3.         rangeCheck(index);
  4.         // 从数组获取值，即 elementData[index]
  5.         return elementData(index);
  6.     }

例如size方法， 就是返回了size属性的值。

  1.     public int size() {
  2.         return size;
  3.     }

而isEmpty方法，就是判断size是否为0.

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

在ArrayList中，有一个获取子集合的subList方法，这个方法返回的是一个内部类SubList，该类并没重新创建新的数组，依旧持有了ArrayList数组的元素的引用，所以当修改ArrayList元素的时候，SubList的元素也会跟着修改，这个在实际开发中一定要注意。

  1.     public List<E> subList(int fromIndex, int toIndex) {
  2.         subListRangeCheck(fromIndex, toIndex, size);
  3.         return new SubList(this, 0, fromIndex, toIndex);
  4.     }

ArrayList实现原理（JDK1.8）的更多相关文章

  1. HashMap实现原理(jdk1.7)，源码分析

    HashMap实现原理(jdk1.7),源码分析 ​ HashMap是一个用来存储Key-Value键值对的集合,每一个键值对都是一个Entry对象,这些Entry被以某种方式分散在一个数组中,这个数 ...

  2. javase基础回顾（一）ArrayList深入解析 解读ArrayList源代码（JDK1.8.0_92）

    我们在学习这一块内容时需要注意的一个问题是 集合中存放的依然是对象的引用而不是对象本身. List接口扩展了Collection并声明存储一系列元素的类集的特性.使用一个基于零的下标,元素可以通过它们 ...

  3. HashMap底层实现原理(JDK1.8)源码分析

    ref:https://blog.csdn.net/tuke_tuke/article/details/51588156 http://www.cnblogs.com/xiaolovewei/p/79 ...

  4. 透过源码分析ArrayList运作原理

    List接口的主要实现类ArrayList,是线程不安全的,执行效率高:底层基于Object[] elementData 实现,是一个动态数组,它的容量能动态增加和减少.可以通过元素下标访问对象,使用 ...

  5. ArrayList实现原理

    转载:http://wiki.jikexueyuan.com/project/java-collection/arraylist.html ArrayList 概述 ArrayList 可以理解为动态 ...

  6. 【Java基础】ArrayList工作原理

    ArrayList 以数组实现.节约空间,但数组有容量限制.超出限制时会增加50%容量,用System.arraycopy()复制到新的数组.因此最好能给出数组大小的预估值.默认第一次插入元素时创建大 ...

  7. Java中HashMap底层实现原理(JDK1.8)源码分析

    这几天学习了HashMap的底层实现,但是发现好几个版本的,代码不一,而且看了Android包的HashMap和JDK中的HashMap的也不是一样,原来他们没有指定JDK版本,很多文章都是旧版本JD ...

  8. ArrayList实现原理及源码分析之JDK8

    转载 ArrayList源码分析 一.ArrayList介绍 Java 集合框架主要包括两种类型的容器: 一种是集合(Collection),存储一个元素集合. 一种是图(Map),存储键/值对映射. ...

  9. ArrayList集合（JDK1.8）

    简述 List是继承于Collection接口,除了Collection通用的方法以外,扩展了部分只属于List的方法. 常用子类  ?ArrayList介绍 1.数据结构 其底层的数据结构是数组,数 ...

随机推荐

  1. vue-cli3安装jQuery

    注:vue-cli3.0 没有了 webpack.config.js 配置文件,取而代之的是集合在 vue.config.js文件 内进行配置 默认已经安装好vue-cli3.0项目 step1:命令 ...

  2. centOS7 永久关闭防火墙

    查看防火墙状态: systemctl status firewalld.service 如图 绿的running表示防火墙开启 执行关闭命令: systemctl stop firewalld.ser ...

  3. 作为一名程序员，你真正了解CDN技术吗？

    本文导读: 物流仓库配送如何加速 静态资源文件部署方式 静态资源加速之CDN技术 解析过程中的名词解释 最后的总结 1.物流仓库配送如何加速 我们还是从生活中购物的例子来展开. 将时光倒回到几年前,在 ...

  4. Java 用单向循环链表实现 约瑟夫问题

    public class lianbiao2 { class Node{ Node next; int number; public Node getNext() { return next; } p ...

  5. NOI1995 石子合并 [Luogu P1880]

    一道区间dp的模板题,这里主要记一下dp时环形数据的处理. 简略版:方法一:枚举分开的位置,将圈化为链,因此要做n次. 方法二:将链重复两次,即做一个2n-1长度的链,其中第i(i<=n)堆石子 ...

  6. 学习笔记56_WebServices

    1.Web services,就是新建项,选择Web服务: 2. 然后可以用Winform来调用webServices: 然后添加“服务引用”,,命名空间可以自己填. 3. 直接 new ,然后调用就 ...

  7. Spring Boot 配置 - Consul 配置中心

    ▶ Spring Boot 依赖与配置 Maven 依赖 <dependencyManagement> <dependencies> <dependency> &l ...

  8. PHP判断是否为手机端的方法

    PHP判断是否为手机端的方法 private function ismobile() { // 如果有HTTP_X_WAP_PROFILE则一定是移动设备 if (isset($_SERVER['HT ...

  9. 关于BootStrap的相关介绍

    一.Bootstrap Bootstrap的官网:www.bootcss.com 1.响应式布局 Responsive web page 响应式/自适应的网页 可以根据浏览器设备的不同(pc,pad, ...

  10. Linux命令实战（五）

    1.显示/etc目录下,以非字母开头,后面跟了一个字母以及其他任意长度字符的文件或目录. [qiuhom@test ~]$ls -d /etc/[^[:alpha:]][[:alpha:]]* ls: ...