当前页面: 在线文档首页 > JavaTM 2 Platform Standard Edition 5.0 API 规范中文版
java.util
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。
Vector (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| 上一个类 下一个类 | 框架 无框架 | |||||||||
| 摘要： 嵌套 | 字段 | 构造方法 | 方法 | 详细信息： 字段 | 构造方法 | 方法 | |||||||||
java.util
类 Vector<E>
java.lang.Objectjava.util.AbstractCollection<E>
- 所有已实现的接口：
- Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
- 直接已知子类：
- Stack
public class Vector<E>
- extends AbstractList<E>
- implements List<E>, RandomAccess, Cloneable, Serializable
- extends AbstractList<E>
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按 capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。
从 Java 2 平台 v1.2 开始，已改进此类以实现 List，这样它就成为了 Java 的集合框架的一部分。与新集合的实现不同，Vector 是同步的。
由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration 不是 快速失败的。
注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。
此类是 Java Collections Framework 的成员。
- 从以下版本开始：
- 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)
构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。 |
|
Vector(int initialCapacity)
使用指定的初始容量和等于零的容量增量构造一个空向量。 |
|
Vector(int initialCapacity,
int capacityIncrement)
使用指定的初始容量和容量增量构造一个空的向量。 |
|
| 方法摘要 | ||
|---|---|---|
boolean |
add(E o)
将指定元素追加到此向量的末尾。 |
|
void |
add(int index,
E element)
在此向量的指定位置插入指定的元素。 |
|
boolean |
addAll(Collection<? extends E> c)
将指定 Collection 中的所有元素追加到此向量的末尾，按照指定集合的迭代器所返回的顺序追加这些元素。 |
|
boolean |
addAll(int index,
Collection<? extends E> c)
在指定位置将指定 Collection 中的所有元素插入到此向量中。 |
|
void |
addElement(E obj)
将指定的组件添加到此向量的末尾，将其大小增加 1。 |
|
int |
capacity()
返回此向量的当前容量。 |
|
void |
clear()
从此向量中移除所有元素。 |
|
Object |
clone()
返回向量的一个副本。 |
|
boolean |
contains(Object elem)
测试指定的对象是否为此向量中的组件。 |
|
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 elem)
搜索给定参数的第一个匹配项，使用 equals 方法测试相等性。 |
|
int |
indexOf(Object elem,
int index)
搜索给定参数的第一个匹配项，从 index 处开始搜索，并使用 equals 方法测试其相等性。 |
|
void |
insertElementAt(E obj,
int index)
将指定对象作为此向量中的组件插入到指定的 index 处。 |
|
boolean |
isEmpty()
测试此向量是否不包含组件。 |
|
E |
lastElement()
返回此向量的最后一个组件。 |
|
int |
lastIndexOf(Object elem)
返回指定的对象在此向量中最后一个匹配项的索引。 |
|
int |
lastIndexOf(Object elem,
int index)
向后搜索指定的对象，从指定的索引处开始搜索，并返回一个索引。 |
|
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()
返回一个数组，包含此向量中以正确顺序存放的所有元素。 |
|
|
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)
- 构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。
- 参数：
c- 其元素要放入此向量中的集合。- 抛出：
NullPointerException- 如果指定的集合为 null。- 从以下版本开始：
- 1.2
| 方法详细信息 |
|---|
copyInto
public void copyInto(Object[] anArray)
- 将此向量的组件复制到指定的数组中。此向量中索引
k 处的项将复制到 anArray 的组件 k 中。数组必须足够大，能够保存此向量中的所有对象，否则抛出 IndexOutOfBoundsException。
- 参数：
anArray- 要将组件复制到其中的数组。- 抛出：
NullPointerException- 如果给定的数组为 null。
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 处的项，依此类推。
- 返回：
- 此向量的组件的枚举。
- 另请参见：
Enumeration,Iterator
contains
public boolean contains(Object elem)
- 测试指定的对象是否为此向量中的组件。
- 指定者：
- 接口
Collection<E>中的contains - 指定者：
- 接口
List<E>中的contains - 覆盖：
- 类
AbstractCollection<E>中的contains
- 参数：
elem- 一个对象。- 返回：
- 当且仅当指定的对象与此向量中的某个组件相同时（由 equals 方法确定）返回
true；否则返回false。
indexOf
public int indexOf(Object elem)
- 搜索给定参数的第一个匹配项，使用
equals方法测试相等性。- 参数：
elem- 一个对象。- 返回：
- 返回参数在此向量中的第一个匹配项的索引，也就是使elem.equals(elementData[k]) 为 true 的最小值 k；如果未找到该对象，则返回
-1。 - 另请参见：
Object.equals(Object)
indexOf
public int indexOf(Object elem, int index)
- 搜索给定参数的第一个匹配项，从
index处开始搜索，并使用equals方法测试其相等性。- 参数：
elem- 一个对象。index- 非负索引，从此处开始搜索。- 返回：
- 返回对象参数在此向量中
index位置或之后位置的第一个匹配项的索引，也就是 elem.equals(elementData[k]) && (k >= index) 为 true 的最小值 k；如果未找到该对象，则返回-1（如果 index 大于等于此 Vector 的当前大小，则返回-1）。 - 抛出：
IndexOutOfBoundsException- 如果 index 为负数。- 另请参见：
Object.equals(Object)
lastIndexOf
public int lastIndexOf(Object elem)
- 返回指定的对象在此向量中最后一个匹配项的索引。
- 指定者：
- 接口
List<E>中的lastIndexOf - 覆盖：
- 类
AbstractList<E>中的lastIndexOf
- 参数：
elem- 需要的组件。- 返回：
- 返回指定对象在此向量中的最后一个匹配项的索引，也就是使 elem.equals(elementData[k]) 为 true 的最大值 k；如果未找到该对象，则返回
-1。
lastIndexOf
public int lastIndexOf(Object elem, int index)
- 向后搜索指定的对象，从指定的索引处开始搜索，并返回一个索引。
- 参数：
elem- 需要的组件。index- 索引，从此处开始搜索。- 返回：
- 返回指定对象在此向量中
index位置或之前位置的最后一个匹配项的索引，也就是使elem.equals(elementData[k]) && (k >= index) 为 true 的最大值 k；如果未找到该对象，则返回-1（如果 index 为负数，则返回-1）。 - 抛出：
IndexOutOfBoundsException- 如果 index 大于或等于此向量的当前大小。
elementAt
public E elementAt(int index)
- 返回指定索引处的组件。
此方法的功能与 get 方法的功能完全相同（后者是 List 接口的一部分）。
- 参数：
index- 此向量的一个索引。- 返回：
- 指定索引处的组件。
- 抛出：
ArrayIndexOutOfBoundsException- 如果 index 为负数或小于此给定 Vector 对象的当前大小。- 另请参见：
get(int),List
firstElement
public E firstElement()
- 返回此向量的第一个组件（位于索引 0 处的项）。
- 返回：
- 此向量的第一个组件。
- 抛出：
NoSuchElementException- 如果此向量没有组件。
lastElement
public E lastElement()
- 返回此向量的最后一个组件。
- 返回：
- 向量的最后一个组件，即索引
size() - 1处的组件。 - 抛出：
NoSuchElementException- 如果此向量为空。
setElementAt
public void setElementAt(E obj, int index)
- 将此向量指定
index处的组件设置为指定的对象。丢弃该位置以前的组件。索引必须为一个大于或等于
0且小于向量当前大小的值。此方法的功能与 set 方法的功能完全相同（后者是 List 接口的一部分）。请注意，set 方法将反转参数的顺序，与数组用法更为匹配。另外还要注意，set 方法将返回以前存储在指定位置的旧值。
- 参数：
obj- 组件将要设置为的内容。index- 指定的索引。- 抛出：
ArrayIndexOutOfBoundsException- 如果索引无效。- 另请参见：
size(),List,set(int, java.lang.Object)
removeElementAt
public void removeElementAt(int index)
- 删除指定索引处的组件。此向量中的每个索引大于或等于指定
index的组件都将下移，使其索引值变成比以前小 1 的值。此向量的大小将减 1。索引必须为一个大于或等于
0且小于向量当前大小的值。此方法的功能与 remove 方法的功能完全相同（后者是 List 接口的一部分）。注意，remove 方法将返回存储在指定位置的旧值。
- 参数：
index- 要移除对象的索引。- 抛出：
ArrayIndexOutOfBoundsException- 如果索引无效。- 另请参见：
size(),remove(int),List
insertElementAt
public void insertElementAt(E obj, int index)
- 将指定对象作为此向量中的组件插入到指定的
index处。此向量中的每个索引大于或等于指定index的组件都将向上移位，使其索引值变成比以前大 1 的值。索引必须为一个大于或等于
0且小于或等于向量当前大小的值（如果索引等于向量的当前大小，则将新元素追加到向量）。此方法的功能与 add(Object, int) 方法的功能完全相同（后者是 List 接口的一部分）。注意，add 方法将反转参数的顺序，与数组用法更为匹配。
- 参数：
obj- 要插入的组件。index- 新组件的插入位置。- 抛出：
ArrayIndexOutOfBoundsException- 如果索引无效。- 另请参见：
size(),add(int, Object),List
addElement
public void addElement(E obj)
- 将指定的组件添加到此向量的末尾，将其大小增加 1。如果向量的大小比容量大，则增大其容量。
此方法的功能与 add(Object) 方法的功能完全相同（后者是 List 接口的一部分）。
- 参数：
obj- 要添加的组件。- 另请参见：
add(Object),List
removeElement
public boolean removeElement(Object obj)
- 从此向量中移除变量的第一个（索引最小的）匹配项。如果在此向量中找到该对象，那么向量中索引大于或等于该对象索引的每个组件都会下移，使其索引值变成比以前小 1 的值。
此方法的功能与 remove(Object) 方法的功能完全相同（后者是 List 接口的一部分）。
- 参数：
obj- 要移除的组件。- 返回：
- 如果变量值是此向量的一个组件，则返回
true；否则返回false。 - 另请参见：
List.remove(Object),List
removeAllElements
public void removeAllElements()
clone
public Object clone()
- 返回向量的一个副本。副本中将包含一个对内部数据数组克隆的引用，而非对此 Vector 对象的原始内部数据数组的引用。
- 返回：
- 向量的一个副本。
- 另请参见：
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- 运行时类型不是此向量中每个元素的运行时类型的超类型。NullPointerException- 如果给定的数组为 null。- 从以下版本开始：
- 1.2
get
public E get(int index)
- 返回向量中指定位置的元素。
- 参数：
index- 要返回元素的索引。- 返回：
- 指定索引处的对象。
- 抛出：
ArrayIndexOutOfBoundsException- 索引超出范围 (index < 0 || index >= size())。- 从以下版本开始：
- 1.2
set
public E set(int index, E element)
- 用指定的元素替换此向量中指定位置处的元素。
- 参数：
index- 要替换元素的索引。element- 要存储在指定位置的元素。- 返回：
- 以前位于指定位置处的元素。
- 抛出：
ArrayIndexOutOfBoundsException- 索引超出范围 (index < 0 || index >= size())。- 从以下版本开始：
- 1.2
add
public boolean add(E o)
- 将指定元素追加到此向量的末尾。
- 指定者：
- 接口
Collection<E>中的add - 指定者：
- 接口
List<E>中的add - 覆盖：
- 类
AbstractList<E>中的add
- 参数：
o- 要追加到此向量的元素。- 返回：
- true（按照 Collection.add 的常规协定）。
- 从以下版本开始：
- 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）。
- 参数：
index- 要在其位置插入指定元素的索引。element- 要插入的元素。- 抛出：
ArrayIndexOutOfBoundsException- 索引超出范围 (index < 0 || index > size())。- 从以下版本开始：
- 1.2
remove
public E remove(int index)
- 移除此向量中指定位置的元素。将所有后续元素左移（将其索引减 1）。返回此向量中移除的元素。
- 参数：
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<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。
- 抛出：
NullPointerException- 如果指定的 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。
- 抛出：
NullPointerException- 如果指定的集合为 null。- 从以下版本开始：
- 1.2
- 另请参见：
AbstractCollection.remove(Object),AbstractCollection.contains(Object)
addAll
public boolean addAll(int index,
Collection<? extends E> c)
- 在指定位置将指定 Collection 中的所有元素插入到此向量中。将当前位于该位置的元素（如果有）及所有后续元素右移（增大其索引值）。新元素在向量中按照其由指定集合的迭代器所返回的顺序出现。
- 参数：
index- 要插入指定集合的第一个元素的索引。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，使正在进行的迭代产生错误的结果）。
- 参数：
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- 要移除的最后一个元素之后的索引。
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| 上一个类 下一个类 | 框架 无框架 | |||||||||
| 摘要： 嵌套 | 字段 | 构造方法 | 方法 | 详细信息： 字段 | 构造方法 | 方法 | |||||||||
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。
版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。