文章目录

概述
方法的执行效率
源码剖析
- 底层数据结构 -数组
- 构造函数
- 自动扩容机制
- set()
- get
- add()/addAll()
- remove()
- trimToSize()
- indexOf(), lastIndexOf()
- Fail-Fast

概述

从类的继承图上我们可知道，ArrayList实现了List接口。

同时List是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，
ArrayList底层基于数组实现。
每个ArrayList都有一个容量(capacity)，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。
当向容器中添加元素时，如果容量不足，容器自动扩容。
ArrayList<E>，可以看到是泛型类型， Java泛型只是编译器提供的语法糖，数组是一个Object数组，可以容纳任何类型的对象。

方法的执行效率

size(), isEmpty(), get(), set()方法均能在常数时间内完成
add()方法的时间开销跟插入位置有关
addAll()方法的时间开销跟添加元素的个数成正比。
其余方法大都是线性时间。

为追求效率，ArrayList没有实现同步(synchronized)，如果需要多个线程并发访问，用户可以手动同步，也可使用Vector替代

源码剖析

底层数据结构 -数组

构造函数

  /*** Constructs an empty list with the specified initial capacity.** @param  initialCapacity  the initial capacity of the list* @throws IllegalArgumentException if the specified initial capacity*         is negative*/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);}}/*** Constructs an empty list with an initial capacity of ten.*/public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}/*** Constructs a list containing the elements of the specified* collection, in the order they are returned by the collection's* iterator.** @param c the collection whose elements are to be placed into this list* @throws NullPointerException if the specified collection is null*/public ArrayList(Collection<? extends E> c) {Object[] a = c.toArray();if ((size = a.length) != 0) {if (c.getClass() == ArrayList.class) {elementData = a;} else {elementData = Arrays.copyOf(a, size, Object[].class);}} else {// replace with empty array.elementData = EMPTY_ELEMENTDATA;}}

演示如下：

/*** 初始化的时候指定容量*/List list = new ArrayList<>(1);list.add(1);list.add(2);System.out.println(list.size());/*** 默认构造函数 ，数组大小为0*/list = new ArrayList();list.add("artisan");list.add("review");list.add("java");System.out.println(list.size());/*** 使用集合初始化一个ArrayList*/list = new ArrayList(Arrays.asList("I" , "Love" ,"Code"));System.out.println(list.size());

自动扩容机制

每当向数组中添加元素时，都需要检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容，以满足添加数据的需求。
数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量的增长大约是其原容量的1.5倍。

这种操作的代价是很高的，因此在实际使用时，我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时，要在构造ArrayList实例时，就指定其容量，以避免数组扩容的发生。

或者根据实际需求，通过调用ensureCapacity方法来手动增加ArrayList实例的容量。

ArrayList#ensureCapacity(int minCapacity)暴漏了public方法可以允许程序猿手工扩容增加ArrayList实例的容量，以减少递增式再分配的数量。

我们来看下效率对比

 /*** 扩容对比*/long begin = System.currentTimeMillis();// 初始化1亿的数据量final int number = 100000000 ;Object o = new Object();ArrayList list1 = new ArrayList<String>();for (int i = 0; i < number; i++) {list1.add(o);}System.out.println("依赖ArrayList的自动扩容机制，添加数据耗时:" +(System.currentTimeMillis() - begin));begin = System.currentTimeMillis();ArrayList list2 = new ArrayList<String>();// 手工扩容list2.ensureCapacity(number);for (int i = 0; i < number; i++) {list2.add(o);}System.out.println("手工ensureCapacity扩容后，添加数据耗时:" + (System.currentTimeMillis() - begin));

原因是因为，第一段如果没有一次性扩到想要的最大容量的话，它就会在添加元素的过程中，一点一点的进行扩容，要知道对数组扩容是要进行数组拷贝的，这就会浪费大量的时间。如果已经预知容器可能会装多少元素，最好显示的调用ensureCapacity这个方法一次性扩容到位。

过程图如下：

set()

底层是一个数组, 那ArrayList的set()方法也就是直接对数组的指定位置赋值

    /*** Replaces the element at the specified position in this list with* the specified element.** @param index index of the element to replace* @param element element to be stored at the specified position* @return the element previously at the specified position* @throws IndexOutOfBoundsException {@inheritDoc}*/public E set(int index, E element) {rangeCheck(index);E oldValue = elementData(index);elementData[index] = element;return oldValue;}

get

get()方法也很简单，需要注意的是由于底层数组是Object[]，得到元素后需要进行类型转换。

  /*** Returns the element at the specified position in this list.** @param  index index of the element to return* @return the element at the specified position in this list* @throws IndexOutOfBoundsException {@inheritDoc}*/public E get(int index) {rangeCheck(index);return elementData(index);}

  @SuppressWarnings("unchecked")E elementData(int index) {return (E) elementData[index];}

add()/addAll()

这两个方法都是向容器中添加新元素，这可能会导致capacity不足，因此在添加元素之前，都需要进行剩余空间检查，如果需要则自动扩容。扩容操作最终是通过grow()方法完成的

/*** Appends the specified element to the end of this list.** @param e element to be appended to this list* @return <tt>true</tt> (as specified by {@link Collection#add})*/public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;}/*** Inserts the specified element at the specified position in this* list. Shifts the element currently at that position (if any) and* any subsequent elements to the right (adds one to their indices).** @param index index at which the specified element is to be inserted* @param element element to be inserted* @throws IndexOutOfBoundsException {@inheritDoc}*/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) 在末尾添加
add(int index, E e)需要先对元素进行移动，然后完成插入操作，也就意味着该方法有着线性的时间复杂度。

addAll()方法能够一次添加多个元素，根据位置不同也有两个把本

一个是在末尾添加的addAll(Collection<? extends E> c)方法，

一个是从指定位置开始插入的addAll(int index, Collection<? extends E> c)方法。

跟add()方法类似，在插入之前也需要进行空间检查，如果需要则自动扩容；如果从指定位置插入，也会存在移动元素的情况。]

addAll()的时间复杂度不仅跟插入元素的多少有关，也跟插入的位置相关。

 /*** Appends all of the elements in the specified collection to the end of* this list, in the order that they are returned by the* specified collection's Iterator.  The behavior of this operation is* undefined if the specified collection is modified while the operation* is in progress.  (This implies that the behavior of this call is* undefined if the specified collection is this list, and this* list is nonempty.)** @param c collection containing elements to be added to this list* @return <tt>true</tt> if this list changed as a result of the call* @throws NullPointerException if the specified collection is null*/public boolean addAll(Collection<? extends E> c) {Object[] a = c.toArray();int numNew = a.length;ensureCapacityInternal(size + numNew);  // Increments modCountSystem.arraycopy(a, 0, elementData, size, numNew);size += numNew;return numNew != 0;}/*** Inserts all of the elements in the specified collection into this* list, starting at the specified position.  Shifts the element* currently at that position (if any) and any subsequent elements to* the right (increases their indices).  The new elements will appear* in the list in the order that they are returned by the* specified collection's iterator.** @param index index at which to insert the first element from the*              specified collection* @param c collection containing elements to be added to this list* @return <tt>true</tt> if this list changed as a result of the call* @throws IndexOutOfBoundsException {@inheritDoc}* @throws NullPointerException if the specified collection is null*/public boolean addAll(int index, Collection<? extends E> c) {rangeCheckForAdd(index);Object[] a = c.toArray();int numNew = a.length;ensureCapacityInternal(size + numNew);  // Increments modCountint 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;}

remove()

remove()方法也有两个方法

一个是remove(int index)删除指定位置的元素
一个是remove(Object o)删除第一个满足o.equals(elementData[index])的元素

 /*** Removes the element at the specified position in this list.* Shifts any subsequent elements to the left (subtracts one from their* indices).** @param index the index of the element to be removed* @return the element that was removed from the list* @throws IndexOutOfBoundsException {@inheritDoc}*/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 workreturn oldValue;}

删除操作是add()操作的逆过程，需要将删除点之后的元素向前移动一个位置。需要注意的是为了让GC起作用，必须显式的为最后一个位置赋null值。

上面代码中如果不手动赋null值，除非对应的位置被其他元素覆盖，否则原来的对象就一直不会被回收。

/*** Removes the first occurrence of the specified element from this list,* if it is present.  If the list does not contain the element, it is* unchanged.  More formally, removes the element with the lowest index* <tt>i</tt> such that* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>* (if such an element exists).  Returns <tt>true</tt> if this list* contained the specified element (or equivalently, if this list* changed as a result of the call).** @param o element to be removed from this list, if present* @return <tt>true</tt> if this list contained the specified element*/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;}

trimToSize()

将底层数组的容量调整为当前列表保存的实际元素的大小

  /*** Trims the capacity of this <tt>ArrayList</tt> instance to be the* list's current size.  An application can use this operation to minimize* the storage of an <tt>ArrayList</tt> instance.*/public void trimToSize() {modCount++;if (size < elementData.length) {elementData = (size == 0)? EMPTY_ELEMENTDATA: Arrays.copyOf(elementData, size);}}

indexOf(), lastIndexOf()

获取元素的第一次出现的index

   /*** Returns the index of the first occurrence of the specified element* in this list, or -1 if this list does not contain the element.* More formally, returns the lowest index <tt>i</tt> such that* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,* or -1 if there is no such 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;}

获取元素的最后一次出现的index

    /*** Returns the index of the last occurrence of the specified element* in this list, or -1 if this list does not contain the element.* More formally, returns the highest index <tt>i</tt> such that* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,* or -1 if there is no such index.*/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;}

Fail-Fast

ArrayList同样采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

具体参考前段时间写的一篇博文如下：

Java - Java集合中的快速失败Fail Fast 机制

Java Review - ArrayList 源码解读相关推荐

Java Review - PriorityQueue源码解读
文章目录 Pre PriorityQueue 概述 PriorityQueue 继承关系 PriorityQueue通过用数组表示的小顶堆实现时间复杂度构造函数方法 add()和offer() ...
Java Review - LinkedList源码解读
文章目录 Pre 概述底层数据结构-双向链表源码解析构造函数方法源码分析 getFirst() getLast() remove相关方法 remove(e) remove(index) rem ...
ArrayList源码解读
ArrayList源码解读底层数据结构 ArrayList是在底层维护了一个elementData数组,添加了自动扩容等功能,最终形成了一个动态数组. 基本属性 // 初始化大小 private s ...
java基本集合源码解读-JDK8/11
文章目录前言详尽的debugger底层查看源码配置一.集合体系图二.List类集合 2.1.1 ArrayList 2.1.2ArrayList底层源码分析结论: 2.1.3 使用Array ...
java1.8 indexes_java1.8源码之ArrayList源码解读
文章目录一.ArrayList概述1.1 ArrayList简介1.2 ArrayList数据结构二.ArrayList源码分析2.1 ArrayList继承结构和层次关系2.2 类的属性2.3 ...
JDK12下的ArrayList源码解读与 Vector的对比
ArrayList源码阅读. //测试代码实现如下 private static void arrayList() {ArrayList<String> list = new ArrayL ...
Java中ArrayList源码分析
一.简介 ArrayList是一个数组队列,相当于动态数组.每个ArrayList实例都有自己的容量,该容量至少和所存储数据的个数一样大小,在每次添加数据时,它会使用ensureCapacity()保 ...
Java集合-ArrayList源码解析-JDK1.8
◆ ArrayList简介 ◆ ArrayList 是一个数组队列,相当于动态数组.与Java中的数组相比,它的容量能动态增长.它继承于AbstractList,实现了List, RandomAcc ...
java Map toString() 源码解读测试
1. 编写一个单元测试类 @Testpublic void tt() {Map<Object, Object> map = new HashMap<>();map.put(&q ...

Java Review - ArrayList 源码解读