java 容器（collection）--ArrayList 常用方法分析 源码分析

ArrayList 介绍

打开jdk源码看看官方文档的介绍

粗糙的翻译下大致意思是：

List接口的可调整大小的数组实现。实现了所有可选的列表操作，并允许所有元素，包括 null 。除了实现List接口之外，这个类提供了操作数组大小的方法。

ArrayList定义的属性

 /**
     * 默认容量大小10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空构造器调用
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 缓冲区
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * 元素个数
     */
    private int size;

无参构造器

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

这个相当于创建一个空数组：

this.elementData={};

有参构造器

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

他的健壮性比较好，我们按正常思维，只看第一个 initialCapacity > 0 的 if 分支：

相当于创建一个长度为 20 的数值：

this.elementData=new Object[20];

添加方法 add(Object obj)

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

这个代码技术含量挺高，不愧是老司机写的

ensureCapacityInternal(size + 1); 用来 检测空间容量是否够用（看下一个方法）

elementData[size++] = e; 就是添加元素相当于：

elementData[size]=e; size++;

检测空间容量是否够用

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

这个方法首先会在内部调用calculateCapacity(elementData, minCapacity) 计算容量：

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

当我们在新建一个ArrayList 对象上添加元素时：

Math.max(DEFAULT_CAPACITY, minCapacity); 相当于：

Math.max(10,1);

到这里容量计算完了，然后回去执行：

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

由于是第一次添加，if 条件相当于：

if( 10 - 0 > 0)

结果为true，会执行if语句块

grow(minCapacity); 执行的就是扩容方法。

扩容方法

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

我们是第一次添加，以上代码实际执行的就是：

int oldCapactiy=0;

int newCapacity=0+0>>1 结果为0

如果 0-10<0 为 true

newCapacity=10;

数组拷贝 elementData的长度就是 10

最后回到：

public boolean add(E e) {

ensureCapacityInternal(size + 1); // Increments modCount!!

elementData[size++] = e;

return true;

}

结果就是：

elementData[0] = e;

size++;

接下来看下add 的重载方法

add(int index, E element)

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

rangeCheckForAdd(index);是下标越界检测，我们先不看，下一行代码：

ensureCapacityInternal(size + 1);跟之前的默认位置天机一样先检测数组的空间容量。

关键是再往下一行代码;

执行的结果是把要插入位置开始到结束的所有元素往后挪一个位置，然后把空出的位置赋值为传入有的参数，同时把元素个数+1；

现在ArrayList对象的容量是10了，当我么一直做添加操作，容量满了会怎么样呢？

其实不管我们怎么添加，都会执行ensureCapacityInternal(size + 1) 来检测容量，而ensureCapacityInternal(size + 1)又会调用calculateCapacity(elementData, minCapacity)直到

ensureExplicitCapacity(int minCapacity)方法中的if语句成立时，执行

grow(minCapacity);进行扩容：

比如我们加到第11个元素时：

grow(minCapacity)方法中的

oldCapacity + (oldCapacity >> 1);返回15；

那么ArrayList的容量就增加到15了；

继续增加还是一样的操作。

至此，我们已经对ArrayList 创建，添加，扩容有了一定了解。

那么剩下的一些方法就是数组的操作了，很好理解。

ArrayList的其他方法

get(int index)根据索引获取元素对象

public E get(int index) {
        rangeCheck(index);
		//调用了elementData()的方法
        return elementData(index);
    }
 @SuppressWarnings("unchecked")
    E elementData(int index) {
    	//根据索引取出数组中索引对象
        return (E) elementData[index];
    }

size()

  public int size() {
  		// 返回集合记录的元素个数
        return size;
    }

isEmpty()

public boolean isEmpty() {
	// 这个太简单了，不必多说
        return size == 0;
    }

set(int index, Object obj)

public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

就是数组操作，返回替换掉的元素

remove(int index)

 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; //   将最后一个位置设置为null

        return oldValue;
    }

类似于前面的指定位置添加，返回原始元素对象

clear()

public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

循环遍历，所有 索引位置的元素赋值null,并把元素个数设置为0；

水平有限，先写到这了。