ArrayList 一篇就够

平常开发中以下语句可能是最经常写的语句之一

List<Integer> list = new ArrayList<>();

结构 数组

继承关系

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList实现的接口有Collection，List，RandomAccess，Serializable等接口。一个个看

1. RandomAccess
   接口中内容是空的，通过官网的API，这是一个标志接口，下面引入一段官网的原文：

public interface RandomAccess
Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.
公共接口RandomAccess，List实现使用的标记接口，指示它们支持快速（通常为恒定时间）随机访问。
官网还特意说明了，如果是实现了这个接口的 List，那么使用for循环的方式获取数据会优于用迭代器获取数据。

2. Serializable
   接口中内容是空的，是一个标志接口
   一个类只有实现了Serializable接口，它的对象才能被序列化，将对象状态转换为可保持或传输的格式的过程。标识给jvm帮忙序列化。
3. Collection，List
   集合的统一接口。统一定义了一套单列集合的接口

核心属性

• DEFAULT_CAPACITY = 10; 默认初始容量。
• Object[] elementData; 数据区 数据存放的位置
• int size;当前List中的个数

构造方法

无参数构造方法，赋值个默认的空数组给数据区

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

指定容量构造方法，创建一个指定大小的Object数组赋值给数据区

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

指定数据构造方法，创建一个List并且放入参数集合中的元素

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

核心方法 public boolean add(E e)

modCount，这个成员变量记录着集合的修改次数，也就每次add或者remove它的值都会加1，因为ArrayList不是线程安全的，如果一个在线程在修改，一个线程在读，那么modCount不相等用来做快速失败的。
接着检查是否需要扩容，size+1如果大于数组可存放的长度就进行grow扩容，反之存放进数组中下一个位置，增加size。

public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }
    
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

核心方法 private void grow(int minCapacity)

扩容以确保它至少可以容纳当前所有元素。
oldCapacity >> 1 将二进制整体右移指定位数，类似除以2向下取整。新的容量是旧的容量的1.5倍
最后使用Arrays.copyOf()创建一个新的数组并且将元素拷贝到新的数组返回。
数组 Arrays.copyOf(源,需要拷贝的长度)

private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //在第一次add时oldCapacity=0，newCapacity=0,做的处理
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //检查是否超过最大可存放数
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

核心方法 public E get(int index)

返回此列表中指定位置的元素，没啥好说的用下标访问数组

    public E get(int index) {
        //做一个index范围检查，大于等于size则越界抛错
        rangeCheck(index);
        return (E) elementData[index];
    }

System.arraycopy

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
Object src : 原数组
int srcPos : 从元数据的起始位置开始
Object dest : 目标数组
int destPos : 目标数组的开始起始位置
int length : 要copy的数组的长度

核心方法 public E remove(int index) 根据下标移除元素

移除指定下标位置的元素。
将下标的后面的所有元素向前移动一格。如果下标在末尾则不需移动。

public E remove(int index) {
        //下标是否越界检查
        rangeCheck(index);
        modCount++;
        //先获取需要移除的元素
        E oldValue = (E) elementData[index];
        //确定要移动的元素个数
        int numMoved = size - index - 1;
        //如果去除的是最后一个元素，则元素不必移动
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        //清楚引用，help gc
        elementData[--size] = null; 

        return oldValue;
    }

核心方法 public boolean remove(Object o) 移除相等元素

没啥好说的，遍历数组然后比较，相同就调用fastRemove移除，代码和上文中的移除元素一致。
比较调用的是equals方法，所以要求你存放的对象重写equals方法，不然比较的是地址，具体看业务需求。

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

本文地址：https://blog.csdn.net/wsdfym/article/details/109601664