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

2023-01-30 22:50:29

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；

水平有限，先写到这了。

码农公寓