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)

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

將當前位置的元素（如果有）和任何后續(xù)元素向右移動（將其添加到索引中）。

remove

public E remove?(int index)

刪除此列表中指定位置的元素。 將任何后續(xù)元素向左移位（從索引中減去一個元素）。

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)

從指定位置開始，將指定集合中的所有元素插入此列表。

將當前位置的元素（如果有）和任何后續(xù)元素向右移動（增加其索引）。

新元素將按照指定集合的迭代器返回的順序出現在列表中。

removeRange

protected void removeRange?(int fromIndex, int toIndex)

從此列表中刪除索引介于fromIndex （含）和toIndex （獨占）之間的所有元素。

將任何后續(xù)元素向左移動（降低其索引）。 此調用通過(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