【Java源码分析】ArrayList源码分析

淡淡的烟草味﹌ 2022-09-23 08:47 113阅读 0赞

类的定义

  1. public class ArrayList<E> extends AbstractList<E>
  2.     implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}
  1. List接口的实现类，AbstractList 的子类，支持随机访问，因此底层实现的数据结构是数组
  2. 实现了所有list的操作，允许所有类型的元素，包括NULL
  3. 提供计算Array大小的接口，可以看做是一个Vector，区别在于Vector是线程安全的，ArrayList不是
  4. 由于底层实现数据结构是数组，所以get set iterator遍历, 以及size判断等都是常数时间。其他操作是线性时间复杂度，而且常数因子比LinkedList要小，因此效率略高
  5. 含有一个容量capacity实例，表示容量的大小，随着数据的加入，该实例会自增，自增
  6. 非线程安全，因此如果在多线程环境下需要自行处理线程安全问题，也可以使用Collections.synchronizedList方法List list = Collections.synchronizedList(new ArrayList(...));进行包装，而且最好是在声明变量的时候就考虑是否需要做多线程的处理，避免出错
  7. ConcurrentModificationException异常，如果ArrayList的实例在使用迭代器Iterator遍历的时候，如果出现了不是使用这个迭代器所做的remove或者add操作，那么就会直接抛出并发修改的异常。这个异常即使是在单线程下也是会出现的，常见的场景是用迭代器一边遍历一边修改ArrayList对象的时候
  8. 对于7中的现象也叫做是fail-fast，该行为只能尽量检测出并发异常，但是不能做到绝对的线程安全，所以编程的时候不要因为没有抛出该异常就觉得是线程安全的

构造函数
三种类型，默认构造(默认构造的Listd的size 为10)，传递size的构造，传递一个Collection对象的构造。

  1. public ArrayList(int initialCapacity) {
  2.     super();
  3.     if (initialCapacity < 0)
  4.         throw new IllegalArgumentException("Illegal Capacity: "+
  5.                                            initialCapacity);
  6.     this.elementData = new Object[initialCapacity];
  7. }
  9. public ArrayList() {
  10.     this(10);
  11. }
  13. public ArrayList(Collection<? extends E> c) {
  14.     elementData = c.toArray();
  15.     size = elementData.length;
  16.     // c.toArray might (incorrectly) not return Object[] (see 6260652)
  17.     if (elementData.getClass() != Object[].class)
  18.         elementData = Arrays.copyOf(elementData, size, Object[].class);
  19. }

扩容方式

  1. private transient Object[] elementData; // 对象数组，实际存放数据的一个数组容器，默认初始10个Object
  2. private int size; // 实际存放对象数目
  3. private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 最大容量；由于一些虚拟机会在Array首部存储一些信息，所以此处减去8字节 
  5. private void grow(int minCapacity) {
  6.     // overflow-conscious code
  7.     int oldCapacity = elementData.length;
  8.     int newCapacity = oldCapacity + (oldCapacity >> 1);
  9.     if (newCapacity - minCapacity < 0)
  10.         newCapacity = minCapacity;
  11.     if (newCapacity - MAX_ARRAY_SIZE > 0)
  12.         newCapacity = hugeCapacity(minCapacity);
  13.     // minCapacity is usually close to size, so this is a win:
  14.     elementData = Arrays.copyOf(elementData, newCapacity);
  15. }

扩容发生在增加元素的时候发现现有数组放不下了，就调用该扩容函数。由于扩容的过程中存在着拷贝过程，而拷贝是整个集合的拷贝，所以还是很影响性能的，因此最好在开始的时候能够预估将要使用多大的容量，避免使用过程中频繁的扩容。扩容的思路是默认扩大为原来的1.5倍，如果指定值minCapacity比原来容量的1.5倍大，那么按指定值扩容；如果指定值minCapacity比阈值MAX_ARRAY_SIZE大，那么按如下策略确定扩容最终大小(minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;，这样会存在一定的OOM风险

减少容量，用于减少一个ArrayList实例所占存储空间

  1. public void trimToSize() {
  2.     modCount++;
  3.     int oldCapacity = elementData.length;
  4.     if (size < oldCapacity) {
  5.         elementData = Arrays.copyOf(elementData, size);
  6.     }
  7. }

从如下的一个侧面说明ArrayList是允许空的对象存入的。

  1. public int indexOf(Object o) {
  2.     if (o == null) {
  3.         for (int i = 0; i < size; i++)
  4.             if (elementData[i]==null)
  5.                 return i;
  6.     } else {
  7.         for (int i = 0; i < size; i++)
  8.             if (o.equals(elementData[i]))
  9.                 return i;
  10.     }
  11.     return -1;
  12. }

连接集合类Collection和线性表Array类的桥梁，该方法将集合中所存储的对象拷贝到一个对象数组中返回

  1. public Object[] toArray() {
  2.     return Arrays.copyOf(elementData, size);
  3. }

该方法还有另外一个多态实现，根据运行时类型返回指定类型的数组

  1. public <T> T[] toArray(T[] a) { ... }

添加一个元素到集合

  1. public void add(int index, E element) {
  2.     rangeCheckForAdd(index);
  4.     ensureCapacityInternal(size + 1);  // Increments modCount!!
  5.     System.arraycopy(elementData, index, elementData, index + 1,
  6.                      size - index);
  7.     elementData[index] = element;
  8.     size++;
  9. }

这个是添加到指定位置的，所以比较麻烦，需要拷贝移动。还有一个添加操作是直接添加到尾部，public boolean add(E e) { ... }只需要做一次赋值即可

删除指定位置的元素

  1. public E remove(int index) {
  2.     rangeCheck(index);
  4.     modCount++;
  5.     E oldValue = elementData(index);
  7.     int numMoved = size - index - 1;
  8.     if (numMoved > 0)
  9.         System.arraycopy(elementData, index+1, elementData, index,
  10.                          numMoved);
  11.     elementData[--size] = null; // Let gc do its work
  13.     return oldValue;
  14. }

从代码来看也是比较好懂的，删除指定位置元素，然后指定位置之后的元素前移，这是一个数组拷贝过程。但是需要注意最后一点，就是将最后一个空出的位置置空，这个问题在Effective Java中有提到过，就是及时的消除过期引用。对于一些自定义的数组类如果对象被移走了，但是指针没有置为空，那么强引用还是会一直保持，就会导致内存泄露。

另一个删除操作是删除指定对象

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

其中用到了一个私有的删除操作fastRemove(index)，该操作的特点是不检查边界也不返回被删除值，毕竟是自己内部调用，已经可以保证边界是正确的。

清空操作

  1. public void clear() {
  2.     modCount++;
  4.     // Let gc do its work
  5.     for (int i = 0; i < size; i++)
  6.         elementData[i] = null;
  8.     size = 0;
  9. }

比较直接，循环置空，然后将对象的清除工作交给GC，注意clear只是将内容清空，集合容器还是在的、

删除集合中某些元素

  1. public boolean removeAll(Collection<?> c) {
  2.     return batchRemove(c, false);
  3. }

功能就是将所有位于c中的元素全部删除

保留集合中某些元素

  1. public boolean retainAll(Collection<?> c) {
  2.     return batchRemove(c, true);
  3. }

功能就是将所有位于c中的元素全部保留，不在c中的元素全部删除
对比这两个方法就可以看出，实际的工作都是由private boolean batchRemove(Collection<?> c, boolean complement) {}完成的，当第二个参数是true的时候代表保留元素，否则代表删除。

集合数据的状态保存和恢复

  1. private void writeObject(java.io.ObjectOutputStream s)
  2.     throws java.io.IOException{
  3.     // Write out element count, and any hidden stuff
  4.     int expectedModCount = modCount;
  5.     s.defaultWriteObject();
  7.     // Write out array length
  8.     s.writeInt(elementData.length);
  10.     // Write out all elements in the proper order.
  11.     for (int i=0; i<size; i++)
  12.         s.writeObject(elementData[i]);
  14.     if (modCount != expectedModCount) {
  15.         throw new ConcurrentModificationException();
  16.     }
  18. }

恢复，将数据从流中取出

  1. private void readObject(java.io.ObjectInputStream s)
  2.     throws java.io.IOException, ClassNotFoundException {
  3.     // Read in size, and any hidden stuff
  4.     s.defaultReadObject();
  6.     // Read in array length and allocate array
  7.     int arrayLength = s.readInt();
  8.     Object[] a = elementData = new Object[arrayLength];
  10.     // Read in all elements in the proper order.
  11.     for (int i=0; i<size; i++)
  12.         a[i] = s.readObject();
  13. }

类似于序列化和反序列化，这里状态保存和恢复也是成对出现的，保存和恢复的顺序都是一样的，否则不可能得到正确的对象或者集合。注意在保存状态的时候同样是不能够修改集合的，否则也是抛出并发修改异常

再来看看ArrayList的迭代器

  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;
  6.     public boolean hasNext() {
  7.         return cursor != size;
  8.     }
  10.     @SuppressWarnings("unchecked")
  11.     public E next() {
  12.         checkForComodification();
  13.         int i = cursor;
  14.         if (i >= size)
  15.             throw new NoSuchElementException();
  16.         Object[] elementData = ArrayList.this.elementData;
  17.         if (i >= elementData.length)
  18.             throw new ConcurrentModificationException();
  19.         cursor = i + 1;
  20.         return (E) elementData[lastRet = i];
  21.     }
  23.     public void remove() {
  24.         if (lastRet < 0)
  25.             throw new IllegalStateException();
  26.         checkForComodification();
  28.         try {
  29.             ArrayList.this.remove(lastRet);
  30.             cursor = lastRet;
  31.             lastRet = -1;
  32.             expectedModCount = modCount;
  33.         } catch (IndexOutOfBoundsException ex) {
  34.             throw new ConcurrentModificationException();
  35.         }
  36.     }
  38.     final void checkForComodification() {
  39.         if (modCount != expectedModCount)
  40.             throw new ConcurrentModificationException();
  41.     }
  42. }

前面说迭代器的时候提到过在使用同一个迭代器迭代访问元素的时候，是不能修改集合的结构的(也就是大小，但是内容变化大小不变还是可以的比如add(index, value)或者set(index, value)是可以的，但是add(value)不可以，该操作会modCount++)，愿意就在于每当初始化一个迭代器实例的时候，该迭代器都保存了当前集合的修改次数。迭代器的每一个操作结束之后都会检查保存的值是否和集合的modCount值相同，如果不同直接抛出异常并且结束，这就是所谓的fail-fast

获取子集合操作

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

返回从fromIndex到toIndex之间的元素构成的子集合，不包括toIndex。当toIndex和fromIndex相等的时候返回的是空的子集合而不是空指针。

注意SubListprivate class SubList extends AbstractList<E> implements RandomAccess {}是ArrayList的一个内部子类，该子类实现了和ArrayList一样的方法.

最后补充一下经常调用的连个拷贝函数Arrays.copyOf(elementData, newCapacity)和System.arraycopy(elementData, index, elementData, index + 1, size - index);

前者最终调用了Arrays的copyOf()方法

  1. public static <T> T[] copyOf(T[] original, int newLength) {
  2.     return (T[]) copyOf(original, newLength, original.getClass());
  3. }

该方法实现如下

  1. public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
  2.     T[] copy = ((Object)newType == (Object)Object[].class)
  3.         ? (T[]) new Object[newLength]
  4.         : (T[]) Array.newInstance(newType.getComponentType(), newLength);
  5.     System.arraycopy(original, 0, copy, 0,
  6.                      Math.min(original.length, newLength));
  7.     return copy;
  8. }

实现的过程是先确定泛型类型，然后调用系统的copy函数，将指定集合中的元素拷贝到目标集合中，目标集合是一个新建的newLength大小的集合。在实际的拷贝过程中还是调用了System.arraycopy()函数

是一个Native方法

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

该方法将srcPos+length-1个元素拷贝到dest中从destPos到destPos+length-1。由于是Native方法，所以在JDK中是看不到的，但是可以在openJDK中查看源码。该函数实际上最终调用了C语言的memmove()函数，因此它可以保证同一个数组内元素的正确复制和移动，比一般的复制方法的实现效率要高很多，很适合用来批量处理数组。Java强烈推荐在复制大量数组元素时用该方法，以取得更高的效率。

发表评论

表情：
评论列表 （有 0 条评论，113人围观）

还没有评论，来说两句吧...

相关阅读

    相关 ArrayList源码分析

    构造函数（有参和无参）： 无参：有个被transient关键字修饰的elementData的Object类型长度为0的数组。 有参：参数的含义就是这个集合的含量，在Arra

    男娘i男娘i/ 0 赞/ 682 阅读