java.util
類別 Vector<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.Vector<E>

所有已實作的介面：

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

直接已知子類別：

Stack

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

Vector 類別可以實作可增長的物件陣列。與陣列一樣，它包含可以使用整數索引進行存取的元件。但是，Vector 的大小可以根據需要增大或縮小，以適應創建 Vector 後進行添加或移除項的操作。

每個向量會試圖通過維護 capacity 和 capacityIncrement 來優化存儲管理。capacity 始終至少應與向量的大小相等；這個值通常比後者大些，因為隨著將元件添加到向量中，其存儲將按 capacityIncrement 的大小增加存儲塊。應用程序可以在插入大量元件前增加向量的容量；這樣就減少了增加的重分派的量。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失敗的：如果在迭代器創建後的任意時間從結構上修改了向量（通過迭代器自身的 remove 或 add 方法之外的任何其他方式），則迭代器將拋出 ConcurrentModificationException。因此，面對共時的修改，迭代器很快就完全失敗，而不是冒著在將來不確定的時間任意發生不確定行為的風險。Vector 的 elements 方法返回的 Enumeration 不是 快速失敗的。

注意，迭代器的快速失敗行為不能得到保證，一般來說，存在不同步的共時修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力拋出 ConcurrentModificationException。因此，編寫依賴於此異常的程序的方式是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測 bug。

從 Java 2 平臺 v1.2 開始，此類別改進為可以實作 List 介面，使它成為 Java Collections Framework 的成員。與新 collection 實作不同，Vector 是同步的。

從以下版本開始：

JDK1.0

另請參見：

Collection, List, ArrayList, LinkedList, 序列化表格

欄位摘要

protected int	capacityIncrement 向量的大小大於其容量時，容量自動增加的量。
protected int	elementCount Vector 物件中的有效元件數。
protected Object[]	elementData 存儲向量元件的陣列緩衝區。

從類別 java.util.AbstractList 繼承的欄位

modCount

建構子摘要

Vector()
建構一個空向量，使其內部資料陣列的大小為 10，其標準容量增量為零。

Vector(Collection<? extends E> c)
建構一個套件含指定 collection 中的元素的向量，這些元素按其 collection 的迭代器返回元素的順序排列。

Vector(int initialCapacity)
使用指定的初始容量和等於零的容量增量建構一個空向量。

Vector(int initialCapacity, int capacityIncrement)
使用指定的初始容量和容量增量建構一個空的向量。

方法摘要

boolean	add(E e) 將指定元素添加到此向量的末尾。
void	add(int index, E element) 在此向量的指定位置插入指定的元素。
boolean	addAll(Collection<? extends E> c) 將指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的順序添加這些元素。
boolean	addAll(int index, Collection<? extends E> c) 在指定位置將指定 Collection 中的所有元素插入到此向量中。
void	addElement(E obj) 將指定的元件添加到此向量的末尾，將其大小增加 1。
int	capacity() 返回此向量的當前容量。
void	clear() 從此向量中移除所有元素。
Object	clone() 返回向量的一個副本。
boolean	contains(Object o) 如果此向量包含指定的元素，則返回 true。
boolean	containsAll(Collection<?> c) 如果此向量包含指定 Collection 中的所有元素，則返回 true。
void	copyInto(Object[] anArray) 將此向量的元件複製到指定的陣列中。
E	elementAt(int index) 返回指定索引處的元件。
Enumeration<E>	elements() 返回此向量的元件的列舉。
void	ensureCapacity(int minCapacity) 增加此向量的容量（如有必要），以確保其至少能夠保存最小容量參數指定的元件數。
boolean	equals(Object o) 比較指定對象與此向量的相等性。
E	firstElement() 返回此向量的第一個元件（位於索引 0) 處的項）。
E	get(int index) 返回向量中指定位置的元素。
int	hashCode() 返回此向量的雜湊碼值。
int	indexOf(Object o) 返回此向量中第一次出現的指定元素的索引，如果此向量不包含該元素，則返回 -1。
int	indexOf(Object o, int index) 返回此向量中第一次出現的指定元素的索引，從 index 處正向搜尋，如果未找到該元素，則返回 -1。
void	insertElementAt(E obj, int index) 將指定物件作為此向量中的元件插入到指定的 index 處。
boolean	isEmpty() 測試此向量是否不包含元件。
E	lastElement() 返回此向量的最後一個元件。
int	lastIndexOf(Object o) 返回此向量中最後一次出現的指定元素的索引；如果此向量不包含該元素，則返回 -1。
int	lastIndexOf(Object o, int index) 返回此向量中最後一次出現的指定元素的索引，從 index 處逆向搜尋，如果未找到該元素，則返回 -1。
E	remove(int index) 移除此向量中指定位置的元素。
boolean	remove(Object o) 移除此向量中指定元素的第一個比對項，如果向量不包含該元素，則元素保持不變。
boolean	removeAll(Collection<?> c) 從此向量中移除包含在指定 Collection 中的所有元素。
void	removeAllElements() 從此向量中移除全部元件，並將其大小設置為零。
boolean	removeElement(Object obj) 從此向量中移除變數的第一個（索引最小的）比對項。
void	removeElementAt(int index) 刪除指定索引處的元件。
protected void	removeRange(int fromIndex, int toIndex) 從此 List 中移除其索引位於 fromIndex（包括）與 toIndex（不包括）之間的所有元素。
boolean	retainAll(Collection<?> c) 在此向量中僅保留包含在指定 Collection 中的元素。
E	set(int index, E element) 用指定的元素替換此向量中指定位置處的元素。
void	setElementAt(E obj, int index) 將此向量指定 index 處的元件設置為指定的物件。
void	setSize(int newSize) 設置此向量的大小。
int	size() 返回此向量中的元件數。
List<E>	subList(int fromIndex, int toIndex) 返回此 List 的部分視圖，元素範圍為從 fromIndex（包括）到 toIndex（不包括）。
Object[]	toArray() 返回一個陣列，包含此向量中以恰當順序存放的所有元素。
<T> T[]	toArray(T[] a) 返回一個陣列，包含此向量中以恰當順序存放的所有元素；返回陣列的運行時型別為指定陣列的型別。
String	toString() 返回此向量的字元串表示形式，其中包含每個元素的 String 表示形式。
void	trimToSize() 對此向量的容量進行微調，使其等於向量的當前大小。

從類別 java.util.AbstractList 繼承的方法

iterator, listIterator, listIterator

從類別 java.lang.Object 繼承的方法

finalize, getClass, notify, notifyAll, wait, wait, wait

從介面 java.util.List 繼承的方法

iterator, listIterator, listIterator

欄位詳細資訊

elementData

protected Object[] elementData

存儲向量元件的陣列緩衝區。vector 的容量就是此資料緩衝區的長度，該長度至少要足以包含向量的所有元素。

Vector 中的最後一個元素後的任何陣列元素都為 null。

elementCount

protected int elementCount

Vector 物件中的有效元件數。從 elementData[0] 到 elementData[elementCount-1] 的元件均為實際項。

capacityIncrement

protected int capacityIncrement

向量的大小大於其容量時，容量自動增加的量。如果容量的增量小於等於零，則每次需要增大容量時，向量的容量將增大一倍。

建構子詳細資訊

Vector

public Vector(int initialCapacity,
              int capacityIncrement)

使用指定的初始容量和容量增量建構一個空的向量。

參數：

initialCapacity - 向量的初始容量

capacityIncrement - 當向量溢位時容量增加的量

拋出：

IllegalArgumentException - 如果指定的初始容量為負數

Vector

public Vector(int initialCapacity)

使用指定的初始容量和等於零的容量增量建構一個空向量。

參數：

initialCapacity - 向量的初始容量

拋出：

IllegalArgumentException - 如果指定的初始容量為負數

Vector

public Vector()

建構一個空向量，使其內部資料陣列的大小為 10，其標準容量增量為零。

Vector

public Vector(Collection<? extends E> c)

建構一個套件含指定 collection 中的元素的向量，這些元素按其 collection 的迭代器返回元素的順序排列。

參數：

c - 其元素要放入此向量中的 collection

拋出：

NullPointerException - 如果指定的 collection 為 null

從以下版本開始：

1.2

方法詳細資訊

copyInto

public void copyInto(Object[] anArray)

將此向量的元件複製到指定的陣列中。此向量中索引 k 處的項將複製到 anArray 的元件 k 中。

參數：

anArray - 要將元件複製到其中的陣列

拋出：

NullPointerException - 如果給定的陣列為 null

IndexOutOfBoundsException - 如果指定陣列不夠大，不能夠保存此向量中的所有元件

ArrayStoreException - 如果此向量的元件不屬於可在指定陣列中存儲的運行時型別

另請參見：

toArray(Object[])

trimToSize

public void trimToSize()

對此向量的容量進行微調，使其等於向量的當前大小。如果此向量的容量大於其當前大小，則通過將其內部資料陣列（保存在欄位 elementData 中）替換為一個較小的陣列，從而將容量更改為等於當前大小。應用程序可以使用此操作最小化向量的存儲。

ensureCapacity

public void ensureCapacity(int minCapacity)

增加此向量的容量（如有必要），以確保其至少能夠保存最小容量參數指定的元件數。

如果此向量的當前容量小於 minCapacity，則通過將其內部資料陣列（保存在欄位 elementData 中）替換為一個較大的陣列來增加其容量。新資料陣列的大小將為原來的大小加上 capacityIncrement，除非 capacityIncrement 的值小於等於零，在後一種情況下，新的容量將為原來容量的兩倍，不過，如果此大小仍然小於 minCapacity，則新容量將為 minCapacity。

參數：

minCapacity - 需要的最小容量

setSize

public void setSize(int newSize)

設置此向量的大小。如果新大小大於當前大小，則會在向量的末尾添加相應數量的 null 項。如果新大小小於當前大小，則丟棄索引 newSize 處及其之後的所有項。

參數：

newSize - 此向量的新大小

拋出：

ArrayIndexOutOfBoundsException - 如果新大小為負數

capacity

public int capacity()

返回此向量的當前容量。

返回：

當前容量（保存在此向量的 elementData 欄位中的內部資料陣列的長度）

size

public int size()

返回此向量中的元件數。

指定者：

介面 Collection<E> 中的 size

指定者：

介面 List<E> 中的 size

指定者：

類別 AbstractCollection<E> 中的 size

返回：

此向量中的元件數

isEmpty

public boolean isEmpty()

測試此向量是否不包含元件。

指定者：

介面 Collection<E> 中的 isEmpty

指定者：

介面 List<E> 中的 isEmpty

覆寫：

類別 AbstractCollection<E> 中的 isEmpty

返回：

當且僅當此向量沒有元件（也就是說其大小為零）時返回 true；否則返回 false。

elements

public Enumeration<E> elements()

返回此向量的元件的列舉。返回的 Enumeration 物件將產生此向量中的所有項。產生的第一項為索引 0 處的項，然後是索引 1 處的項，依此類別推。

返回：

此向量的元件的列舉

另請參見：

Iterator

contains

public boolean contains(Object o)

如果此向量包含指定的元素，則返回 true。更確切地講，當且僅當此向量至少包含一個滿足 (o==null ? e==null : o.equals(e)) 的元素 e 時，返回 true。

指定者：

介面 Collection<E> 中的 contains

指定者：

介面 List<E> 中的 contains

覆寫：

類別 AbstractCollection<E> 中的 contains

參數：

o - 測試在此向量中是否存在的元素

返回：

如果此向量包含指定的元素，則返回 true

indexOf

public int indexOf(Object o)

返回此向量中第一次出現的指定元素的索引，如果此向量不包含該元素，則返回 -1。更確切地講，返回滿足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i；如果沒有這樣的索引，則返回 -1。

指定者：

介面 List<E> 中的 indexOf

覆寫：

類別 AbstractList<E> 中的 indexOf

參數：

o - 要搜尋的元素

返回：

此向量中第一次出現的指定元素的索引；如果此向量不包含該元素，則返回 -1

indexOf

public int indexOf(Object o,
                   int index)

返回此向量中第一次出現的指定元素的索引，從 index 處正向搜尋，如果未找到該元素，則返回 -1。更確切地講，返回滿足 (i >= index && (o==null ? get(i)==null : o.equals(get(i)))) 的最低索引 i；如果沒有這樣的索引，則返回 -1。

參數：

o - 要搜尋的元素

index - 搜尋開始處的索引

返回：

此向量中 index 位置或之後位置處第一次出現的指定元素的索引；如果未找到該元素，則返回 -1。

拋出：

IndexOutOfBoundsException - 如果指定索引為負數

另請參見：

Object.equals(Object)

lastIndexOf

public int lastIndexOf(Object o)

返回此向量中最後一次出現的指定元素的索引；如果此向量不包含該元素，則返回 -1。更確切地講，返回滿足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i；如果沒有這樣的索引，則返回 -1。

指定者：

介面 List<E> 中的 lastIndexOf

覆寫：

類別 AbstractList<E> 中的 lastIndexOf

參數：

o - 要搜尋的元素

返回：

此向量中最後一次出現的指定元素的索引；如果此向量不包含該元素，則返回 -1

lastIndexOf

public int lastIndexOf(Object o,
                       int index)

返回此向量中最後一次出現的指定元素的索引，從 index 處逆向搜尋，如果未找到該元素，則返回 -1。更確切地講，返回滿足 (i <= index && (o==null ? get(i)==null : o.equals(get(i)))) 的最高索引 i；如果沒有這樣的索引，則返回 -1。

參數：

o - 要搜尋的元素

index - 逆向搜尋開始處的索引

返回：

此向量中小於等於 index 位置處最後一次出現的指定元素的索引；如果未找到該元素，則返回 -1。

拋出：

IndexOutOfBoundsException - 如果指定索引大於等於此向量的當前大小

elementAt

public E elementAt(int index)

返回指定索引處的元件。

此方法的功能與 get(int) 方法的功能完全相同（後者是 List 介面的一部分）。

參數：

index - 此向量的一個索引

返回：

指定索引處的元件

拋出：

ArrayIndexOutOfBoundsException - 如果該索引超出範圍 (index < 0 || index >= size())

firstElement

public E firstElement()

返回此向量的第一個元件（位於索引 0) 處的項）。

返回：

此向量的第一個元件

拋出：

NoSuchElementException - 如果此向量沒有元件

lastElement

public E lastElement()

返回此向量的最後一個元件。

返回：

向量的最後一個元件，即索引 size() - 1 處的元件。

拋出：

NoSuchElementException - 如果此向量為空

setElementAt

public void setElementAt(E obj,
                         int index)

將此向量指定 index 處的元件設置為指定的物件。丟棄該位置以前的元件。

索引必須為一個大於等於 0 且小於向量當前大小的值。

此方法的功能與 set(int, E) 方法的功能完全相同（後者是 List 介面的一部分）。注意，set 方法將反轉參數的順序，與陣列用法更為比對。另外還要注意，set 方法將返回以前存儲在指定位置的舊值。

參數：

obj - 將用來設置元件的內容

index - 指定的索引

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index >= size())

removeElementAt

public void removeElementAt(int index)

刪除指定索引處的元件。此向量中的每個索引大於等於指定 index 的元件都將下移，使其索引值變成比以前小 1 的值。此向量的大小將減 1。

索引必須為一個大於等於 0 且小於向量當前大小的值。

此方法的功能與 remove(int) 方法的功能完全相同（後者是 List 介面的一部分）。注意，remove 方法將返回存儲在指定位置的舊值。

參數：

index - 要移除物件的索引

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index >= size())

insertElementAt

public void insertElementAt(E obj,
                            int index)

將指定物件作為此向量中的元件插入到指定的 index 處。此向量中的每個索引大於等於指定 index 的元件都將向上移位，使其索引值變成比以前大 1 的值。

索引必須為一個大於等於 0 且小於等於向量當前大小的值（如果索引等於向量的當前大小，則將新元素添加到向量）。

此方法的功能與 add(int, E) 方法的功能完全相同（後者是 List 介面的一部分）。注意，add 方法將反轉參數的順序，與陣列用法更為比對。

參數：

obj - 要插入的元件

index - 新元件的插入位置

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index > size())

addElement

public void addElement(E obj)

將指定的元件添加到此向量的末尾，將其大小增加 1。如果向量的大小比容量大，則增大其容量。

此方法的功能與 add(E) 方法的功能完全相同（後者是 List 介面的一部分）。

參數：

obj - 要添加的元件

removeElement

public boolean removeElement(Object obj)

從此向量中移除變數的第一個（索引最小的）比對項。如果在此向量中找到該物件，那麼向量中索引大於等於該物件索引的每個元件都會下移，使其索引值變成比以前小 1 的值。

此方法的功能與 remove(Object) 方法的功能完全相同（後者是 List 介面的一部分）。

參數：

obj - 要移除的元件

返回：

如果變數值是此向量的一個元件，則返回 true；否則返回 false。

removeAllElements

public void removeAllElements()

從此向量中移除全部元件，並將其大小設置為零。

此方法的功能與 clear() 方法的功能完全相同（後者是 List 介面的一部分）。

clone

public Object clone()

返回向量的一個副本。副本中將包含一個對內部資料陣列副本的參考，而非對此 Vector 物件的原始內部資料陣列的參考。

覆寫：

類別 Object 中的 clone

返回：

向量的一個副本

另請參見：

Cloneable

toArray

public Object[] toArray()

返回一個陣列，包含此向量中以恰當順序存放的所有元素。

指定者：

介面 Collection<E> 中的 toArray

指定者：

介面 List<E> 中的 toArray

覆寫：

類別 AbstractCollection<E> 中的 toArray

返回：

包含此 collection 中所有元素的陣列

從以下版本開始：

1.2

另請參見：

Arrays.asList(Object[])

toArray

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

返回一個陣列，包含此向量中以恰當順序存放的所有元素；返回陣列的運行時型別為指定陣列的型別。如果向量能夠適應指定的陣列，則返回該陣列。否則使用此陣列的運行時型別和此向量的大小分派一個新陣列。

如果向量能夠適應指定的陣列，而且還有多餘空間（即陣列的元素比向量的元素多），則將緊跟向量末尾的陣列元素設置為 null。（僅 在調用者知道向量不包含任何 null 元素的情況下，這對確定向量的長度才有用）。

指定者：

介面 Collection<E> 中的 toArray

指定者：

介面 List<E> 中的 toArray

覆寫：

類別 AbstractCollection<E> 中的 toArray

參數：

a - 要在其中存儲向量元素的陣列（如果該陣列足夠大）；否則，將為此分派一個具有相同運行時型別的新陣列。

返回：

包含向量元素的陣列

拋出：

ArrayStoreException - 如果 a 的運行時型別不是此向量中每個元素的運行時型別的父級類別型

NullPointerException - 如果給定的陣列為 null

從以下版本開始：

1.2

get

public E get(int index)

返回向量中指定位置的元素。

指定者：

介面 List<E> 中的 get

指定者：

類別 AbstractList<E> 中的 get

參數：

index - 要返回元素的索引

返回：

指定索引處的物件

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index >= size())

從以下版本開始：

1.2

set

public E set(int index,
             E element)

用指定的元素替換此向量中指定位置處的元素。

指定者：

介面 List<E> 中的 set

覆寫：

類別 AbstractList<E> 中的 set

參數：

index - 要替換元素的索引

element - 要存儲在指定位置的元素

返回：

以前位於指定位置處的元素

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index >= size())

從以下版本開始：

1.2

add

public boolean add(E e)

將指定元素添加到此向量的末尾。

指定者：

介面 Collection<E> 中的 add

指定者：

介面 List<E> 中的 add

覆寫：

類別 AbstractList<E> 中的 add

參數：

e - 要添加到此向量的元素

返回：

true（根據 Collection.add(E) 的規定）

從以下版本開始：

1.2

remove

public boolean remove(Object o)

移除此向量中指定元素的第一個比對項，如果向量不包含該元素，則元素保持不變。更確切地講，移除其索引 i 滿足 (o==null ? get(i)==null : o.equals(get(i))) 的元素（如果存在這樣的元素）。

指定者：

介面 Collection<E> 中的 remove

指定者：

介面 List<E> 中的 remove

覆寫：

類別 AbstractCollection<E> 中的 remove

參數：

o - 要從向量中移除的元素（如果存在）

返回：

如果向量包含指定元素，則返回 true

從以下版本開始：

1.2

add

public void add(int index,
                E element)

在此向量的指定位置插入指定的元素。將當前位於該位置的元素（如果有）及所有後續元素右移（將其索引加 1）。

指定者：

介面 List<E> 中的 add

覆寫：

類別 AbstractList<E> 中的 add

參數：

index - 要在其位置插入指定元素的索引

element - 要插入的元素

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index > size())

從以下版本開始：

1.2

remove

public E remove(int index)

移除此向量中指定位置的元素。將所有後續元素左移（將其索引減 1）。返回此向量中移除的元素。

指定者：

介面 List<E> 中的 remove

覆寫：

類別 AbstractList<E> 中的 remove

參數：

index - 要移除元素的索引

返回：

移除的元素

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index >= size())

從以下版本開始：

1.2

clear

public void clear()

從此向量中移除所有元素。此調用返回後，向量將為空（除非拋出了異常）。

指定者：

介面 Collection<E> 中的 clear

指定者：

介面 List<E> 中的 clear

覆寫：

類別 AbstractList<E> 中的 clear

從以下版本開始：

1.2

containsAll

public boolean containsAll(Collection<?> c)

如果此向量包含指定 Collection 中的所有元素，則返回 true。

指定者：

介面 Collection<E> 中的 containsAll

指定者：

介面 List<E> 中的 containsAll

覆寫：

類別 AbstractCollection<E> 中的 containsAll

參數：

c - 要在此向量中測試是否包含其元素的 collection

返回：

如果此向量包含指定 collection 中的所有元素，則返回 true

拋出：

NullPointerException - 如果指定 collection 為 null

另請參見：

AbstractCollection.contains(Object)

addAll

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

將指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的順序添加這些元素。如果指定的 Collection 在操作過程中被修改，則此操作的行為是不確定的（這意味著如果指定的 Collection 是此向量，而此向量不為空，則此調用的行為是不確定的）。

指定者：

介面 Collection<E> 中的 addAll

指定者：

介面 List<E> 中的 addAll

覆寫：

類別 AbstractCollection<E> 中的 addAll

參數：

c - 要插入到此向量的元素

返回：

如果此向量由於調用而更改，則返回 true

拋出：

NullPointerException - 如果指定 collection 為 null

從以下版本開始：

1.2

另請參見：

AbstractCollection.add(Object)

removeAll

public boolean removeAll(Collection<?> c)

從此向量中移除包含在指定 Collection 中的所有元素。

指定者：

介面 Collection<E> 中的 removeAll

指定者：

介面 List<E> 中的 removeAll

覆寫：

類別 AbstractCollection<E> 中的 removeAll

參數：

c - 要從向量中移除的元素的 collection

返回：

如果此向量由於調用而更改，則返回 true

拋出：

ClassCastException - 如果此向量中的一個或多個元素的型別與指定 collection 不相容（可選）

NullPointerException - 如果此向量包含一個或多個 null 元素並且指定 collection 不支持 null 元素（可選），或者指定 collection 為 null

從以下版本開始：

1.2

另請參見：

AbstractCollection.remove(Object), AbstractCollection.contains(Object)

retainAll

public boolean retainAll(Collection<?> c)

在此向量中僅保留包含在指定 Collection 中的元素。換句話說，從此向量中移除所有未包含在指定 Collection 中的元素。

指定者：

介面 Collection<E> 中的 retainAll

指定者：

介面 List<E> 中的 retainAll

覆寫：

類別 AbstractCollection<E> 中的 retainAll

參數：

c - 要在此向量中保留的元素的 collection（移除其他所有元素）

返回：

如果此向量由於調用而更改，則返回 true

拋出：

ClassCastException - 如果此向量中的一個或多個元素的型別與指定 collection 不相容（可選）

NullPointerException - 如果此向量包含一個或多個 null 元素並且指定 collection 不支持 null 元素（可選），或者指定 collection 為 null

從以下版本開始：

1.2

另請參見：

AbstractCollection.remove(Object), AbstractCollection.contains(Object)

addAll

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

在指定位置將指定 Collection 中的所有元素插入到此向量中。將當前位於該位置的元素（如果有）及所有後續元素右移（增大其索引值）。新元素在向量中按照其由指定 collection 的迭代器所返回的順序出現。

指定者：

介面 List<E> 中的 addAll

覆寫：

類別 AbstractList<E> 中的 addAll

參數：

index - 要插入指定 collection 的第一個元素的索引

c - 要插入到此向量的元素

返回：

如果此向量由於調用而更改，則返回 true

拋出：

ArrayIndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index > size())

NullPointerException - 如果指定的 collection 為 null

從以下版本開始：

1.2

equals

public boolean equals(Object o)

比較指定對象與此向量的相等性。當且僅當指定的物件也是一個 List、兩個 List 大小相同，並且其中所有對應的元素對都相等 時才返回 true。（如果 (e1==null ? e2==null : e1.equals(e2))，則兩個元素 e1 和 e2 相等）。換句話說，如果兩個 List 套件含相同順序的相同元素，則這兩個 List 就定義為相等。

指定者：

介面 Collection<E> 中的 equals

指定者：

介面 List<E> 中的 equals

覆寫：

類別 AbstractList<E> 中的 equals

參數：

o - 要與此向量進行相等性比較的物件

返回：

如果指定的 Object 與此向量相等，則返回 true

另請參見：

Object.hashCode(), Hashtable

hashCode

public int hashCode()

返回此向量的雜湊碼值。

指定者：

介面 Collection<E> 中的 hashCode

指定者：

介面 List<E> 中的 hashCode

覆寫：

類別 AbstractList<E> 中的 hashCode

返回：

此列表的雜湊碼值

另請參見：

Object.equals(java.lang.Object), Hashtable

toString

public String toString()

返回此向量的字元串表示形式，其中包含每個元素的 String 表示形式。

覆寫：

類別 AbstractCollection<E> 中的 toString

返回：

此 collection 的字元串表示形式

subList

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

返回此 List 的部分視圖，元素範圍為從 fromIndex（包括）到 toIndex（不包括）。（如果 fromIndex 和 toIndex 相等，則返回的 List 將為空）。返回的 List 由此 List 支持，因此返回 List 中的更改將反映在此 List 中，反之亦然。返回的列表支持此列表支持的所有可選列表操作。

此方法消除了顯式範圍操作的需要（此操作通常針對陣列存在）。通過操作 subList 視圖而非整個 List，期望 List 的任何操作可用作範圍操作。例如，下面的語句從 List 中移除了元素的範圍：

            list.subList(from, to).clear();
 

可以對 indexOf 和 lastIndexOf 建構類似的語句，而且 Collections 類別中的所有演算法都可以應用於 subList。

如果通過任何其他方式（而不是通過返回的列表）從結構上修改 內部 List（即此 List），則此方法返回的 List 的語義將變為不確定的（從結構上修改是指更改 List 的大小，或者以其他方式打亂 List，使正在進行的迭代產生錯誤的結果）。

指定者：

介面 List<E> 中的 subList

覆寫：

類別 AbstractList<E> 中的 subList

參數：

fromIndex - subList的低端點（包括）

toIndex - subList 的高端點（不包括）

返回：

List 中指定範圍的視圖

拋出：

IndexOutOfBoundsException - 如果端點索引值超出範圍 (fromIndex < 0 || toIndex > size)

IllegalArgumentException - 如果端點索引順序錯誤 (fromIndex > toIndex)

removeRange

protected void removeRange(int fromIndex,
                           int toIndex)

從此 List 中移除其索引位於 fromIndex（包括）與 toIndex（不包括）之間的所有元素。將所有後續元素左移（減小其索引值）。此調用會將 ArrayList 縮小 (toIndex - fromIndex) 個元素（如果 toIndex==fromIndex，則此操作沒有任何效果）。

覆寫：

類別 AbstractList<E> 中的 removeRange

參數：

fromIndex - 要移除的第一個元素的索引

toIndex - 要移除的最後一個元素之後的索引