容器-ArrayList底层源码分析（三）

ArrayList底层是用数组实现存储的

用Ctrl+鼠标右键点击ArrayList看源码

 List<String> a1=new ArrayList<>();//用Ctrl+鼠标右键 点击ArrayList看源码

了解ArrayList的继承结构和成员变量，也就是初始化变量。

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

//了解ArrayList的继承结构和成员变量
//ArrayList通过继承AbstractList父类实现
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
        
        
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;//数组的默认长度为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             //elementData很重要的成员变量，为来我们放元素所操作的数组
					//当无参构造器赋值以后，你就变成了一个空数组。
    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;  //记录当前元素的个数

    /**
     * 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
     */
//看下它的无参构造
      /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        
        
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }          //先给elementData附的是一个空数组（节省内存）。

添加数组元素

List<String> a1=new ArrayList<>();
a1.add("a");

用Ctrl+鼠标右键点击add看源码
```
boolean add(E e);
```

在Ctrl+Alt,出现一些add抽象方法的实现类，点击ArrayList中，看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就变成0+1=1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

我们来看ensureCapacityInternal实现的方法

//ensureCapacityInternal传进的参数是1，也就是minCapacity是1
private void ensureCapacityInternal(int minCapacity) {
        
        
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}  //调用ensureExplicitCapacity方法，有嵌套调用了calculateCapacity（计算容量的方法）
	//这时calculateCapacity(elementData, minCapacity)
    //elementData 是一个空数组，minCapacity值是1

然后我们继续来看calculateCapacity（计算容量的方法）

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        
        
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        
        
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //elementData 现在是一个空数组[]，DEFAULTCAPACITY_EMPTY_ELEMENTDATA原来定义的也是一个空数组[]，所以两者肯定是相等的。然后就会返回一个最大值，DEFAULT_CAPACITY定义的默认长度是10，minCapacity是原先传进来的值为1，所以最大值会返回10
    
    return minCapacity;
}

这个calculateCapacity这个被嵌套的方法传出的值是10，也就意味着 ensureExplicitCapacity方法传的是10。

//ensureCapacityInternal传进的参数是1，也就是minCapacity是1
private void ensureCapacityInternal(int minCapacity) {
        
        
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}  //调用ensureExplicitCapacity方法，有嵌套调用了calculateCapacity（计算容量的方法）
	//这时calculateCapacity(elementData, minCapacity)
    //elementData 是一个空数组，minCapacity值是1

然后我们来看 ensureExplicitCapacity方法

private void ensureExplicitCapacity(int minCapacity) {
        
        //ensureExplicitCapacity传进来的参数是10，也就是minCapacity是10
    modCount++;//改动的计时器，添加、删除...元素什么的

    //这个非常重要，让我们判断是否要对数组进行扩容处理
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
//现在minCapacity是10，elementData本来还是个空数组，现在的长度是0，所以条件是10-0=10大于0，满足条件，执行grow()这个核心的方法，数组的扩容。

我们来看grow(minCapacity);数组扩容这个ArryList的最重要、最核心的方法

  private void grow(int minCapacity) {
        
        //现在minCapacity是10
        // overflow-conscious code
        int oldCapacity = elementData.length;//elementData.length是0，所以oldCapacity是0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
      //oldCapacity >> 1，右移一位就是除于2，但是0/2=0，还有加0，所以newCapacity是0
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
      //newCapacity是0，minCapacity是10，newCapacity - minCapacity=-10，小于0满足条件，newCapacity = minCapacity=10，所以现在newCapacity是10
        if (newCapacity - MAX_ARRAY_SIZE > 0)//这来是显然不成立的， MAX_ARRAY_SIZE=Interger-8,显然是一个比10大得很多的数，所以不进这个条件
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
      //这个才是最重要的，Arrays工具类的copyOf方法，elementData是空数组，newCapacity是10，于是现在elementData就变成了一个数组长度为10的数组，这也就完成了添加元素的方法
    }

grow(int minCapacity)执行完，也就是 ensureExplicitCapacity方法执行完，也就是ensureCapacityInternal执行完，也就是最后add要执行完

扫描二维码关注公众号，回复： 12790638 查看本文章

public boolean add(E e) {
        
          //这时的的size是0，ensureCapacityInternal就变成0+1=1
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;//这时的elementData就是长度为10的数组，而现在size是0，++之后就变成了1，所以这样我们就完成了一个元素的添加
    return true;
}

当我们添加第二个元素的时候，是否会扩容，答：不会

添加元素

public boolean add(E e) {
        
          //这时的的size是0，ensureCapacityInternal就变成0+1=1
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;//这时的elementData就是长度为10的数组，而现在size是0，++之后就变成了1，所以这样我们就完成了一个元素的添加
    return true;
}

densureCapacityInternal传的是2

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

calculateCapacity返回的是2

 private static int calculateCapacity(Object[] elementData, int minCapacity) {
        
        
     //elementData是10 ，minCapacity是2
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        
        //DEFAULTCAPACITY_EMPTY_ELEMENTDATA还是空数组，elementData已经是10显然不相等了
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;//就会直接返回2
    }

ensureExplicitCapacity返回是2，接下来我们看ensureExplicitCapacity方法

private void ensureCapacityInternal(int minCapacity) {
        
        
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
//ensureExplicitCapacity这时返回的是2

ensureExplicitCapacity是2，也就是 minCapacity是2，minCapacity - elementData.length=2-10=-8不大于0，所以不会再扩容，所以在minCapacity 在1-10之间都不会扩容，知道minCapacity 是11，才会继续扩容

private void ensureExplicitCapacity(int minCapacity) {
        
        //ensureExplicitCapacity是2，也就是 minCapacity是2
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)//2-10=-8不大于0，所以不会再扩容
        grow(minCapacity);
}

假设数组已经加到11了，会进行1.5倍扩容。也就是minCapacity 是11，最后扩容成长度为15的数组

也就是minCapacity 是11了

private void ensureExplicitCapacity(int minCapacity) {
        
        //ensureExplicitCapacity是2，也就是 minCapacity是2
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)//11-10=1大于0，就会扩容
        grow(minCapacity);
}

我们就来看扩容的方法grow(minCapacity);

   private void grow(int minCapacity) {
        
        //minCapacity=11
        // overflow-conscious code
        int oldCapacity = elementData.length;
       // oldCapacity = elementData.length;=10，所以 oldCapacity是10
        int newCapacity = oldCapacity + (oldCapacity >> 1);
       //newCapacity = oldCapacity + (oldCapacity >> 1)=10+10/2=15,所以newCapacity是15
        if (newCapacity - minCapacity < 0)//15-10=5大于0不执行该条件
            newCapacity = minCapacity;
        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);
       //于是最关键的一步，elementData是10，newCapacity是15，最后elementData变成了一个数组长度为15的数组，又扩容了。
    }

容器-ArrayList底层源码分析（三）

容器-ArrayList底层源码分析（三）

猜你喜欢