1.2.1 构造方法

方法名	说明
public ArrayList()	创建一个空的集合对象

1.2.2 成员方法

方法名	说明
public boolean add(E e)	将指定的元素追加到此集合的末尾
public boolean remove(E e)	删除指定元素,返回值表示是否删除成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数

观察这些方法可以看到主要操作是增删改查。

增：add，其中添加的数据需要是对象，既可以自定义的，也可以是Java自带的类；

删：分为两个，分别是直接删除数据和根据索引删除数据；

改：set，根据索引修改为某个值；

查：get，根据索引查询。

crtl+F12和alt+7可快速查看一个类中的所有方法。

ArrayList底层原理

下面介绍一下JDK17中的ArrayList类源码：

底层存储数据的是一个数组elementData，size是存储的数据个数。

    private static final int DEFAULT_CAPACITY = 10;
    transient Object[] elementData;
    private int size;

1、首先在使用空参构造函数new一个ArrayList对象时会创建一个长度为0的数组。

    // DEFAULTCAPACITY_EMPTY_ELEMENTDATA表示一个长度为0的数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 将elementData初始化为长度为0的数组
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

2、然后首次添加一个元素时，来看一下add(e)方法：

    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }

在这个方法中会调用带有三个参数的add方法，s表示存入数组中的元素个数，由于s = 0，所以会调用无参的grow方法进行扩容。 

    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

下面来看一下grow()方法：

在这个方法中会调用带一个参数的grow方法，并将size+1传过去。

   private Object[] grow() {
        return grow(size + 1);
    }

再来看一下 grow(int minCapacity) 方法：

其中minCapacity表示添加所需的最小容量。

在第一次添加时会执行else后面的语句，创建一个长度为DEFAULT_CAPACITY = 10的数组。

当存第11个元素时会进行扩容，调用了newLength方法。

    private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

比较minCapacity - oldCapacity和oldCapacity >> 1哪个大？ 

当添加一个元素时，minCapacity - oldCapacity = 1，而oldCapacity >> 1 = oldCapacity / 2最小也为5，是肯定大于minCapacity - oldCapacity的，所以扩容后的数组长度为1.5*length。

    public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
        // preconditions not checked because of inlining
        // assert oldLength >= 0
        // assert minGrowth > 0

        int prefLength = oldLength + Math.max(minGrowth, prefGrowth); // might overflow
        if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {
            return prefLength;
        } else {
            // put code cold in a separate method
            return hugeLength(oldLength, minGrowth);
        }
    }

来看一下addAll方法：

    // addAll方法添加的元素为一个集合
    public boolean addAll(Collection<? extends E> c) {
        // 首先将集合c转换为数组a
        Object[] a = c.toArray();
        modCount++;
        // 获取数组a的长度赋给变量numNew
        int numNew = a.length;
        if (numNew == 0)
            return false;
        Object[] elementData;
        final int s;
        //如果numNew大于数组剩下的空间，则将数组需扩容
        if (numNew > (elementData = this.elementData).length - (s = size))
            elementData = grow(s + numNew);
        System.arraycopy(a, 0, elementData, s, numNew);
        size = s + numNew;
        return true;
    }

minCapacity - oldCapacity表示需要增加的数组的长度，oldCapacity / 2表示扩的长度。

如果minCapacity - oldCapacity大于oldCapacity / 2，则证明扩容的长度oldCapacity / 2是不够的，所以此时以minCapacity - oldCapacity为准。 

综上所述底层原理为：

①在创建ArrayList对象时会初始化一个长度为0的数组；

②当首次调用add(e)添加字符串时，会将数组的长度扩容为10；

在后续添加时：

当添加一个元素时且存满时会扩容，扩容之后的数组长度是1.5*length；

如果一次添加很多个元素且超过扩容后的数组长度时则会以实际个数进行扩容。