ArrayList的本质是维护了一个Object的数组

字段

protected int modCount

此列表已被 结构修改（增加、删除）的次数 。

构造方法

方法及使用：

trimToSize

public void trimToSize()

将此ArrayList实例的容量调整为列表的当前大小。

应用程序可以使用此操作来最小化ArrayList实例的存储（就是存了多少个元素，就把长度调整为多少）。

    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

ensureCapacity

public void ensureCapacity​(int minCapacity)

如有必要，增加此 ArrayList实例的容量，以确保它至少可以容纳由minimum

capacity参数指定的元素数。

参数

minCapacity - 所需的最小容量

size

public int size()

返回此列表中的元素数。

isEmpty

public boolean isEmpty()

如果此列表不包含任何元素，则返回 true 。

        list1.add(1);
        System.out.println(list1.isEmpty());//false
        list1.clear();
        System.out.println(list1.isEmpty());//true

contains

public boolean contains​(Object o)

如果此列表包含指定的元素，则返回true

        list1.add(1);
        System.out.println(list1.contains(1));//true
        System.out.println(list1.contains(2));//false

indexOf

public int indexOf​(Object o)

返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。

        list1.add(1);
        System.out.println(list1.indexOf(1));//0
        System.out.println(list1.indexOf(2));//-1

lastIndexOf

public int lastIndexOf​(Object o)

返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1

        list1.add(1);
        list1.add(2);
        list1.add(1);
        System.out.println(list1.lastIndexOf(1));//2
        System.out.println(list1.lastIndexOf(0));//-1

clone

public Object clone()

返回此ArrayList实例的浅表副本。 （元素本身不会被复制。）

详看：ArrayList的clone方法-浅拷贝与深拷贝

toArray

public Object[] toArray()

以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
返回的数组将是“安全的”，因为此列表不会保留对它的引用。 （换句话说，此方法必须分配一个新数组）。 因此调用者可以自由修改返回的数组。

此方法充当基于阵列和基于集合的API之间的桥梁。

public <T> T[] toArray​(T[] a)

以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）;

返回数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。

否则，将为新数组分配指定数组的运行时类型和此列表的大小。

如果列表适合指定的数组，并且有空余空间（即，数组的元素多于列表），紧接集合结尾的数组中的元素将设置为null 。 （ 仅当调用者知道列表不包含任何null元素时，这在确定列表长度时很有用。）

这两个方法都是将列表List中的元素转导出为数组，不同的是，toArray()方法导出的是Object类型数组，而toArray[T[] a]方法导出的是指定类型的数组。

        Object[] objects = list1.toArray();
        Integer[] integers = list1.toArray(new Integer[0]);

get

public E get​(int index)

返回此列表中指定位置的元素。

set

public E set​(int index, E element)

用指定的元素替换此列表中指定位置的元素。

add

public boolean add​(E e)

将指定的元素追加到此列表的末尾。

public void add​(int index, E element)

将指定元素插入此列表中的指定位置。

将当前位置的元素（如果有）和任何后续元素向右移动（将其添加到索引中）。

remove

public E remove​(int index)

删除此列表中指定位置的元素。 将任何后续元素向左移位（从索引中减去一个元素）。

public boolean remove​(Object o)

从该列表中删除指定元素的第一个匹配项（如果存在）。 如果列表不包含该元素，则不会更改。

更正式地，删除具有最低索引i的元素，使得Objects.equals(o, get(i)) （如果存在这样的元素）。

如果此列表包含指定的元素，则返回true （或等效地，如果此列表因调用而更改）。

clear

public void clear()

从此列表中删除所有元素。 此调用返回后，列表将为空。

addAll

public boolean addAll​(Collection<? extends E> c)

将指定集合中的所有元素按指定集合的Iterator返回的顺序附加到此列表的末尾。

如果在操作正在进行时修改了指定的集合，则此操作的行为是不确定的。

（这意味着如果指定的集合是此列表，则此调用的行为是未定义的，并且此列表是非空的。）

public boolean addAll​(int index, Collection<? extends E> c)

从指定位置开始，将指定集合中的所有元素插入此列表。

将当前位置的元素（如果有）和任何后续元素向右移动（增加其索引）。

新元素将按照指定集合的迭代器返回的顺序出现在列表中。

removeRange

protected void removeRange​(int fromIndex, int toIndex)

从此列表中删除索引介于fromIndex （含）和toIndex （独占）之间的所有元素。

将任何后续元素向左移动（降低其索引）。 此调用通过(toIndex - fromIndex)元素缩短列表。
（如果toIndex==fromIndex ，此操作无效。）

removeAll

public boolean removeAll​(Collection<?> c)

从此列表中删除指定集合中包含的所有元素。

retainAll

public boolean retainAll​(Collection<?> c)

仅保留此列表中包含在指定集合中的元素。 换句话说，从该列表中删除未包含在指定集合中的所有元素。

        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();

        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        list1.add(6);

        list2.add(2);
        list2.add(3);

        list1.retainAll(list2);

        for (int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i));
        }

输出结果：

2
3

subList

public List<E> subList​(int fromIndex, int toIndex)

返回指定的fromIndex （包含）和toIndex （独占）之间的此列表部分的视图。

（如果fromIndex和toIndex相等，则返回的列表为空。）返回的列表由此列表支持，因此返回列表中的非结构更改将反映在此列表中，反之亦然。 返回的列表支持所有可选的列表操作。

此方法消除了对显式范围操作的需要（对于数组通常存在的排序）。

任何需要列表的操作都可以通过传递subList视图而不是整个列表来用作范围操作。

        ArrayList<Integer> list1 = new ArrayList<>();

        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        list1.add(6);

        List<Integer> integers = list1.subList(2, 4);
        for (int i = 0; i < integers.size(); i++) {
            System.out.println(integers.get(i));
        }

输出结果：

3
4