ArrayList源码分析基础

2021-01-24 15:02:27 阅读：111 来源： 互联网

标签：分析 index int ArrayList elementData element minCapacity 源码 size

1.先看ArrayList的图：

相关的接口抽象类的介绍：

类名	说明
AbstractCollection	实现了Collection中大量的函数,除了特定的几个函数iterator()和size()之外的函数
AbstractList	该接口继承于AbstractCollection，并且实现List接口的抽象类。它实现了List中除size()、get(int location)之外的函数。 AbstractList的主要作用：它实现了List接口中的大部分函数和AbstractCollection相比，AbstractList抽象类中，实现了iterator()接口
RandomAccess	RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问
List	有序队列接口,提供了一些通过下标访问元素的函数 List是有序的队列，List中的每一个元素都有一个索引；第一个元素的索引值是0，往后的元素的索引值依次+1

ArrayList本质是动态数组。那么ArrayList是如何实现动态扩容的呢?

ArrayList的长度

 /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

ArrayList中存储数据的数组对象

    /**
     * Default initial capacity. 默认初始大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.  一个空对象
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added. 一个空对象，如果使用默认构造函数创建，则默认对象内容默认是该值
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /** 
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.     当前数据对象存放地方
     */
    transient Object[] elementData; // non-private to simplify nested class access

无参构造器

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

elementData=null;无参构造去并不会真实的创建数组，数组会在add方法中去创建，有助于性能的提升，懒加载的方式。

有参构造器

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

add方法分析

    /**
     * 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) {
        // 确定容量，动态扩容 size 初始为0
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //  数组扩容后将数据添加到合适的位置  并size+1
        elementData[size++] = e;
        return true;
    }

　　接下来看：ensureCapacityInternal

 private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

　　接着看：calculateCapacity

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  // 如果使用无参构造函数 第一次为true，返回10 
            return Math.max(DEFAULT_CAPACITY, minCapacity);  // 比较默认值和 minCapacity中的一个大的值
        }
        return minCapacity;
    }

　　接下来看： ensureExplicitCapacity

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;   //操作次数

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)   //判断是否需要扩容 第一次add的时候触发扩容，minCapacity为10
        grow(minCapacity);
}

　　接下来看：grow

    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;  // 获取旧数组的长度
        int newCapacity = oldCapacity + (oldCapacity >> 1); // 将旧数字变为原来的1.5倍（因为左移动1位） 第一次 0 还是变成0
        if (newCapacity - minCapacity < 0) 
            newCapacity = minCapacity; // 第一次add的时候 newCapacity 变为10（无参构造函数）
        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); //把原来数组中的内容拷贝到一个新建的指定容量为newCapacity的数组中，扩容
    }

尝试基本的逻辑：

　　使用无参构造函数

　　第1次add的时候，触发扩容，容量为10。当前数组为：{0,,,,,,,,,}。当前size 1

　　第2次add的时候，不触发扩容，容量为10。当前数组：{0,1,,,,,,,,,} 当前size 2

　　第11次add的时候，触发扩容，容量为15，当前数组为：{0,1,2,3,4,5,6,7,8,9,10,,,,} 当前size 11

执行：
    // ensureExplicitCapacity(11)
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 11 - 10 > 0
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) { // 11
    // 10
    int oldCapacity = elementData.length;
    // 15  newCapacity 是oldCapacity的1.5倍
    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:
    // {0,1,2,3,4,5,6,7,8,9} -- > {0,1,2,3,4,5,6,7,8,9,,,,,}
    elementData = Arrays.copyOf(elementData, newCapacity);
}

　　最终变成：{0,1,2,3,4,5,6,7,8,9,10,,,,}

get方法

/**
     * 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];
    }

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

remove方法

/**
     * 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) { // index = 3
        rangeCheck(index);  检查下标

        modCount++;  
　　　　　// 获取要移动的元素的个数 {0,1,2,3,4,5,6,7,8} // 3  size=9  index=3（下标为3）
        E oldValue = elementData(index); // oldValue = 3

        int numMoved = size - index - 1; // 获取要移动元素的个数 9 - 3 -1 = 5
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);  // 源数组  开始下标 目标数组 开始下标 长度
        // 当前数组：{0,1,2,4,5,6,7,8,,}
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

标签：分析,index,int,ArrayList,elementData,element,minCapacity,源码,size
来源： https://www.cnblogs.com/lxl-six/p/14320903.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9