ArrayList源码解析（JDK8）

妖狐艹你老母 2023-09-25 12:37 58阅读 0赞

#### 文章目录 ####

*  一、ArrayList继承体系
 *  二、ArrayList属性
 *  三、构造方法
 *   *  1、ArrayList(int initialCapacity)
     *  2、ArrayList()
     *  3、ArrayList(Collection<? extends E> c)
 *  四、ArrayList 相关操作方法
 *   *  1、add(E e)
     *  2、add(int index, E element)
     *  3、addAll(Collection<? extends E> c)
     *  4、get(int index)
     *  5、remove(int index)
     *  6、remove(Object o)

--------------------

加油，不要过度焦虑♪(^∇^\*)

--------------------

## 一、ArrayList继承体系 ##

ArrayList又称动态数组，底层是基于数组实现的List，与数组的区别在于，它具备动态扩展能力，从源码看一看ArrayList继承了哪些类？实现了哪些类？

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

可以看出，ArrayList实现了List、RandomAccess、Cloneable、Serializable

*  实现List，具备基本的遍历、删除、添加等操作
 *  实现RandomAccess，支持快速随机访问
 *  实现Cloneable，支持对象被克隆
 *  实现Serializable，支持被序列化

继承体系图：

![在这里插入图片描述][ee6e6ad6f8604d5a8d65a6d9f83ca8d1.png]

--------------------

## 二、ArrayList属性 ##

private static final int DEFAULT_CAPACITY = 10;
        
        private static final Object[] EMPTY_ELEMENTDATA = {
        };
        
        private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
        };
        
        transient Object[] elementData; 
        
        private int size;

*  **DEFAULT\_CAPACITY**：集合的默认容量，默认为10，通过new ArrayList()空参构造器创建实例时的默认容量是10。
 *  **EMPTY\_ELEMENTDATA**：空数组，通过new ArrayList(0)创建List集合实例时用的是这个空数组。
 *  **DEFAULTCAPACITY\_EMPTY\_ELEMENTDATA**：默认容量空数组，这种是通过new ArrayList()无参构造方法创建集合时用的是这个空数组，与EMPTY\_ELEMENTDATA的区别是在添加第一个元素时使用这个空数组的会初始化为DEFAULT\_CAPACITY(10)个元素。
 *  **elementData**：存储数据元素的数组，使用transient修饰，该字段不被序列化。
 *  **size**：存储数据元素的个数，elementData数组的长度并不是存储数据元素的个数。

--------------------

## 三、构造方法 ##

### 1、ArrayList(int initialCapacity) ###

/**
         * Constructs an empty list with the specified initial capacity.
         * 构造具有指定初始容量的空数组
         * @param  initialCapacity  the initial capacity of the list
         * 参数initialCapacity是初始容量
         * @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) {
        
            	//这就是EMPTY_ELEMENTDATA
                this.elementData = EMPTY_ELEMENTDATA;
            } else {
        
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            }
        }

### 2、ArrayList() ###

/**
         * Constructs an empty list with an initial capacity of ten.
         */
        public ArrayList() {
        
        	//这就是DEFAULTCAPACITY_EMPTY_ELEMENTDATA
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        }

### 3、ArrayList(Collection<? extends E> c) ###

/**
         * 构造一个含有具体元素集合的list，按照集合迭代的顺序返回
         * Constructs a list containing the elements of the specified
         * collection, in the order they are returned by the collection's
         * iterator.
         *	//参数c的元素放入list中
         * @param c the collection whose elements are to be placed into this list
         * //如果指定的集合为null，则抛出空指针异常
         * @throws NullPointerException if the specified collection is null
         */
        public ArrayList(Collection<? extends E> c) {
        
        	// 把c转化为数组
            elementData = c.toArray();
            if ((size = elementData.length) != 0) {
        
               // 如果elementData类型不是Object
                if (elementData.getClass() != Object[].class)
                	//则重新拷贝为Object类型
                    elementData = Arrays.copyOf(elementData, size, Object[].class);
            } else {
        
                // 用空数组代替
                this.elementData = EMPTY_ELEMENTDATA;
            }
        }

--------------------

## 四、ArrayList 相关操作方法 ##

### 1、add(E e) ###

添加元素到末尾，平均时间复杂度为 O ( 1 ) O(1) O(1)

/**
        	//添加指定元素到list的末尾
         * Appends the specified element to the end of this list.
         *	//元素e被添加到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) {
        
        	//检查是否需要扩容，minCapacity = (size + 1)
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            //把元素插入到最后一位
            elementData[size++] = e;
            return true;
        }
        //检查是否需要扩容的方法
    	private void ensureCapacityInternal(int minCapacity) {
        
            ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
        }
        //计算最小容量的方法
        private static int calculateCapacity(Object[] elementData, int minCapacity) {
        
        // 如果list={}
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        
        	// 返回最大的一方，DEFAULT_CAPACITY的值为10
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    	//
        private void ensureExplicitCapacity(int minCapacity) {
        
        	//记录被修改的次数
            modCount++;
            // 当存储长度大于现有的长度时，需要扩容
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);//扩容
        }
        /**
    	 *增加容量，确保它可以容纳至少最小容量参数指定的元素数
         * Increases the capacity to ensure that it can hold at least the
         * number of elements specified by the minimum capacity argument.
         * // minCapacity 是最小容量
         * @param minCapacity the desired minimum capacity
         */
        private void grow(int minCapacity) {
        
            // 先计算现有的长度
            int oldCapacity = elementData.length;
            // 扩容1.5倍
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            // 如果新容量发现比需要的容量还小，则以需要的容量为准
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            //如果新容量已经超过最大容量了，则使用最大容量(Integer.MAX_VALUE - 8)
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // 以新容量拷贝出来一个新数组
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
        //使用最大的容量
        private static int hugeCapacity(int minCapacity) {
        
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

最后来分析一下执行流程：

1.  检查是否需要扩容；
2.  如果elementData等于DEFAULTCAPACITY\_EMPTY\_ELEMENTDATA(即为\{\})则初始化容量大小为DEFAULT\_CAPACITY(10)；
3.  新容量是老容量的1.5倍（oldCapacity + (oldCapacity >> 1)），如果加了这么多容量发现比需要的容量还小，则以需要的容量为准；
4.  创建新容量的数组并把老数组按顺序依次拷贝到新数组中；

--------------------

### 2、add(int index, E element) ###

添加元素到指定位置，平均时间复杂度为 O ( n ) O(n) O(n)

/**
         * 在list的指定位置插入指定元素，移动当前位于该位置的元素(如果有的话)和
    右边的任何后续元素(向它们的索引添加1)
         * 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).
         * //index为插入指定元素的索引
         * @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!!
            //这个方法就是在index位置空出来，index后的元素向后移动
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);
            //在index位置插入element
            elementData[index] = element;
            size++;
        }
        private void rangeCheckForAdd(int index) {
        
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

来看看它的执行流程执行流程：

1.  先检查索引是否越界；
2.  然后检查是否需要扩容；
3.  把插入索引位置后的元素都往后挪一位；
4.  最后在插入索引位置放置插入的元素；
5.  元素数量增1；

--------------------

### 3、addAll(Collection<? extends E> c) ###

/**
         * 在list末尾增加collection集合的所有元素
         * 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 modCount
            System.arraycopy(a, 0, elementData, size, numNew);
            size += numNew;
            return numNew != 0;
        }

执行流程：

1.  将c转换为数组；
2.  检查minCapacity = (size + numNew)是否需要扩容；
3.  把数组a中的元素拷贝到elementData的尾部；
4.  size +=numNew

--------------------

### 4、get(int index) ###

获取指定索引位置的元素，时间复杂度为 O ( 1 ) O(1) O(1)。

/**
         * 返回list中指定位置的元素
         * 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);
        }
        private void rangeCheck(int index) {
        
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    	//返回数组index的值
        @SuppressWarnings("unchecked")
        E elementData(int index) {
        
            return (E) elementData[index];
        }

执行流程：检查数组下标是否越界，不越界则返回对应数组下标值。

--------------------

### 5、remove(int index) ###

删除指定索引位置的元素，时间复杂度为 O ( n ) O(n) O(n)。

/**
         * Removes the element at the specified position in this list.
         * 将所有后续元素向左移动(从它们的索引中减去1)
         * 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);
            //修改次数加1
            modCount++;
            //记录数组index下标的值，用oldValue记录下来
            E oldValue = elementData(index);
            //记录需要移动的次数
            int numMoved = size - index - 1;
            //如果要删除的元素不是list的最后一个元素
            if (numMoved > 0)
            	//则把剩余元素向前移动numMoved位
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            //将最后一个元素删除，有助于垃圾回收
            elementData[--size] = null; // clear to let GC do its work
            //返回删除的值
            return oldValue;
        }

来看看执行流程：

1.  首先要检查索引是否越界；
2.  然后获取指定索引位置的元素；
3.  接着如果删除的不是最后一位，则其它元素往前移一位；
4.  将最后一位置为null，方便垃圾回收；
5.  最后返回删除的元素。

需要注意的是：remove的操作并未修改数组的容量！！！

--------------------

### 6、remove(Object o) ###

删除指定元素值的元素，时间复杂度为 O ( n ) O(n) O(n)。

/**
         * 从此列表中删除第一个出现的指定元素(如果存在)
         * 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.  
         * 通俗来说，删除的是index最低的元素
         * More formally, removes the element with the lowest index
         * <tt>i</tt> such that
         * <tt>(o==null ? get(i)==null : 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) {
        
        	//如果要删除的是null值
            if (o == null) {
        
            	//遍历整个list
                for (int index = 0; index < size; index++)
                	//发现list存在null值
                    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;
                    }
            }
            //遍历的过程中都不存在o值，则返回false代表不存在
            return false;
        }
        /*
         * 跳过边界检查且不返回已删除值的私有删除方法
         * fastRemove(int index)相对于remove(int index)少了检查索引越界的操作，可见jdk将性能优化到极致
         * Private remove method that skips bounds checking and does not return the value removed.
         */
        private void fastRemove(int index) {
        
        	//修改次数加1
            modCount++;
            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
        }

执行流程：

1.  找到第一个等于指定元素值的元素；
2.  快速删除；

--------------------

到此结束，感谢阅读(\*^▽^\*)

--------------------

[ee6e6ad6f8604d5a8d65a6d9f83ca8d1.png]: https://img-blog.csdnimg.cn/ee6e6ad6f8604d5a8d65a6d9f83ca8d1.png