ArrayList底层原理分析

一、概述

• 底层原理：是一个Object[] elementData类型，可调整大小（动态）数组
• 特点：
  ①有序可重复(包含null 值)，可通过索引检索
  ②在尾部增加元素和查询元素的性能非常高效，但在中间插入或删除元素时的性能较差
  ③扩容为原容量的1.5倍
  

二、扩容机制

• 当创建一个ArrayList对象时：ArrayList arrayList = new ArrayList();创建一个初始容量为空的ArrayList。

  public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

transient Object[] elementData;	

• 当向创建ArrayList对象中添加元素时，会先进行判断数组是否已满，如果已满，就会调用 ensureCapacityInternal 方法进行扩容。这个方法会计算出新的容量大小，并创建一个新的newElementData，然后将原数组中的元素复制到新数组中，最后将新数组赋值给 elementData。
  

三、boolean add(E e) 源码分析

ArrayList arrayList = new ArrayList();
        arrayList.add(123);

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};	//创建一个容量为空的数组

public boolean add(E e) {
ensureCapacityInternal(size + 1);  //判断当前容量是否足够，不够则扩容
elementData[size++] = e;	//插入元素值末端
return true;
}

private void ensureCapacityInternal(int minCapacity) {
//判断当前容量是否为空值，若为空则将默认值：10，当作新的数组长度
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
     ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
//记录ArrayList对象在结构上发生修改的次数
     modCount++;
    // 条件满足进行扩容操作
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // 旧容量长度
    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);
    // 将原数组扩容到指定的新容量 newCapacity中
    elementData = Arrays.copyOf(elementData, newCapacity);
}

四、boolean addAll(Collection<? extends E> c) 源码分析

ArrayList arrayList = new ArrayList();
List list = new LinkedList();
list.add("abd");
list.add("abde");
arrayList.addAll(list);

• 当arrayList集合对象向容量中通过boolean addAll(Collection<? extends E> c) 方法添加元素时，会先将添加的元素转换成Object[] 类型的数组对象，再将这个数组对象添加到ArrayList对象内部数组当中，添加完成后会更新size（）大小并返回布尔值，判断是否添加成功。

 public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // 判断容量是否足够，进行扩容
    System.arraycopy(a, 0, elementData, size, numNew);//将元素插入到末端
    size += numNew;
    return numNew != 0;
}

• System.arraycopy(a, 0, elementData, size, numNew) 该方法能够快速的将一个数组中的元素复制到另一个数组中

五、 E set(int index, E element) 源码分析

• 调用set(int index, E element)方法时，首先会对索引值进行校验，判断索引是否越界，如果越界则会抛出 IndexOutOfBoundsException 异常。如果索引没有越界，则 set 方法会将指定位置的元素保存到一个临时变量中，然后将当前索引位置的值替换为新元素，并返回原有元素的值。

 	public E set(int index, E element) {
    	rangeCheck(index);	//校验索引是否越界

    	E oldValue = elementData(index);	//将指定位置的元素保存到一个临时变量
   		elementData[index] = element;		//将当前索引位置的值替换为新元素
    	return oldValue;
	}
	private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

六、boolean remove(Object o)源码分析

• 调用boolean remove(Object o)方法时，先会对参数Object o 进行校验，判断Object o是否为null，若为null，则移除数组元素中为null的元素，否则移除与Object o 一致的元素。最后将列表的size属性减1，并将被移除的元素置为null，以便垃圾回收。

      public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);	//快速移除
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; //列表长度减一，将移除元素赋为null
    }

七、E remove(int index) 源码分析

• 调用E remove(int index)方法时，先根据索引值进行判断，校验索引是否越界，将索引位置的元素值保存到一个临时变量中，将int index 索引位置加1到末尾的元素复制到当前索引位置，最后将列表的size属性减1，并将被移除的元素置为null，以便垃圾回收并返回索引位置元素旧值。

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; // clear to let GC do its work

    return oldValue;
}

八、Fail-Fast（快速失败）机制

• 是一种在集合类中用于检测并发修改的机制
• 在使用迭代器遍历集合时，如果集合在迭代过程中被修改，Fail-Fast 机制会立即抛出 ConcurrentModificationException 异常，以保证迭代的安全性。这个机制旨在提早检测到并发修改，并防止可能导致不确定行为或数据损坏的情况发生。
• 实现原理：是通过在集合内部维护一个修改次数（modCount）的计数器。每当对集合进行结构上的修改（例如添加、删除或修改元素）时，都会增加该计数器的值。而在迭代器进行迭代时，会将当前的计数器值记录下来。在每次调用迭代器的 next() 方法时，都会比较记录的计数器值和当前集合的计数器值是否相等，如果不相等就会抛出 ConcurrentModificationException 异常。
• 优点：是能够快速检测到并发修改，避免产生潜在的问题
• 注意事项：
  ①Fail-Fast 机制只能检测到由同一线程进行的修改，不能检测到不同线程之间的并发修改。
  ②ConcurrentModificationException 异常只是一个警告，不能保证在所有情况下都会被触发，因此不能依赖该异常来保证程序的正确性。
  ③在使用迭代器遍历集合时，不要直接修改集合，而应该通过迭代器的相关方法（如 remove()）来进行修改