List源码分析-ArrayList

说明：这个文章是我个人的学习笔记，由于本人水平有限，如果有什么误导的地方，请指正，谢谢

前提

• 对常用的集合进行复习分析，如，ArrayList、LinkedList、Vector

ArrayList

• ArrayList是基于数组实现，可以允许为空，元素可以重复，是有序集合，但是非线程安全
• UML图
  
• 基本属性

   // 默认的初始化容量
    private static final int DEFAULT_CAPACITY = 10;

    // ArrayList 的元素存储的数组缓冲区，存储的对象数组f(transient 关键字是为了该属性不会被序列化，有时间再研究看看为什么)
    transient Object[] elementData; // non-private to simplify nested class access

    // 数组长度
    private int size;

• 初始化的方式
  Array的初始化方式有三种，分别是 无参数直接初始化、指定大小初始化、指定初始数据初始化，具体的源码
  • 指定大小初始化，根据传入参数>0，来初始化一个初始容量为initialCapacity的数组，=0则初始化为空数组，<0抛出异常
  • 无参构造，elementData初始化为空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，第一次调用add方法，则会扩容为DEFAULT_CAPACITY=10
  • 指定初始数据初始化，就是将Collection集合中的元素变为数组的形式

	// 构造一个具有指定初始容量的空列表（指定大小初始化）。
    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);
        }
    }

    // 构造一个初始容量为 10 的空列表,但是初始容量是在第一次add的时候才会指定(无参数直接初始化)
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    // 构造一个包含指定集合元素的列表
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

• 新增方法，add(),方法有两种一个是直接在数组的末尾追加，一种是在任意位置添加，源码如下

  • 计算数组容量，是否超出最大值
  • 如果当前数组为空，则初始化容量为DEFAULT_CAPACITY=10
  • 如果超出了容量最大值，则开始进行扩容
  • 扩容为原来容量的1.5倍
  • 如果发生扩容，将原数组中的元素拷贝

	// 在数组的末尾追加
	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    // 指定位置添加
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 将 index 及其之后的所有元素都向后移一位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 在指定位置插入元素
        elementData[index] = element;
        size++;
    }

这里注意一下方法ensureCapacityInternal，这个方法是确认数组的容量大小，如果超过了初始容量，则需要扩容，数组的扩容会导致整个数组进行一次内存复制。 接下来继续分析扩容的方法

 	private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
	// 计算容量
	private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 如果当前数组为空，则初始容量为DEFAULT_CAPACITY=10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 否则返回当前数组容量（加上了当次的新增的数量）
        return minCapacity;
    }

   

	// 确认容量
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // 所以首次add ，则需要走grow方法
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    // 扩容
	private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 扩容的计算方式：扩容为原来的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 数组复制
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

• get方法没什么好说的就是在数组里面根据下标返回，所以获取元素的效率非常高

@SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }
    public E get(int index) {
        // 检查是否下标越界
        rangeCheck(index);
        return elementData(index);
    }

• remove方法，删除数组元素,删除元素有很多种方式，比如根据数组索引删除、根据值删除或批量删除等等，原理和思路都差不多。
  ArrayList在每一次有效的删除元素操作之后，都要进行数组的重组，并且删除的元素位置越靠前，数组重组的开销就越大。

// 根据索引位置删除
 public E remove(int index) {
        rangeCheck(index);
        modCount++;
        // 删除的值
        E oldValue = elementData(index);
		// 这个值表示，需要从index后移动多少个元素到前面去，-1是因为下标从0开始
        int numMoved = size - index - 1;
        if (numMoved > 0)
        // 拷贝数组，从index+1的位置开始拷贝，拷贝的起始位置是index(就是删除所在的位置)，长度是numMoved
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 数组的最好一个位置赋值为null，等待GC
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

    // 根据元素删除
    public boolean remove(Object o) {
        if (o == null) {
        // 如果删除的元素是null，则进行遍历，删除第一个值为null的元素，也是根据下标删除
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
        // 删除不为null的元素，则进行遍历，取和o进行equals一样的元素删除
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

总结

1. ArrayList是一种变长集合类，基于数组实现，随机提取元素的效率高，默认构造方法的初始容量为10，但是是延迟初始化，是第一次add的时候，才会初始化容量
2. ArrayList允许元素为空，也重复元素
3. ArrayList添加元素的时候，如果元素数量大于数组容量，则进行扩容，扩容的长度为原来的1.5倍
4. ArrayList非线程安全类，多线程环境下，可能会引发不可预知的错误
5. 有序集合，因为删除和随机插入都需要复制数组，性能可能比较差