compact1, compact2, compact3

java.util

Class Vector<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.Vector<E>

All Implemented Interfaces:

Serializable， Cloneable， Iterable ， Collection ， List ， RandomAccess

已知直接子类：

Stack

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

的 Vector类实现了一个可增长对象数组。像一个数组，它包含可以使用整数索引进行访问的组件。然而，一个 Vector大小可以成长或需要适应添加和删除的项目后， Vector已创建收缩。

每个向量都试图保持一个capacity和capacityIncrement优化仓储管理，capacity总是至少为载体的尺寸一样大；它通常是更大的因为组件添加到载体中，在大块的capacityIncrement大小的向量的存储增加。应用程序可以将大量的组件之前增加一个矢量的能力；这将减少增量分配量。

The iterators returned by this class's iterator和listIterator方法快速失败：如果向量进行结构修饰后的迭代器创建的任何时间，以任何方式除了通过迭代器的remove或add方法，迭代器将抛出一个ConcurrentModificationException。因此，在遇到同步修改，迭代器不能快速、干净，而不是冒着任意，非在将来一个不确定的时间确定的行为。的Enumerations返回的elements方法不能快速失败。

注意迭代器不能快速失败行为得到保证的话，一般来说，不可能在不同步的并发修改的存在作出难以保证。快速失败迭代器扔ConcurrentModificationException尽最大努力的基础上。因此，要写一个程序，依靠这一例外的正确性错误：快速失败迭代器的行为只能用来检测错误。

作为java 2平台V1.2，这类改造实施List接口，使得它的 Java Collections Framework成员。不像新采集的实现，Vector是同步的。如果一个线程安全的实现是不需要的，建议在地方Vector使用ArrayList。

从以下版本开始：

JDK1.0

另请参见：

Collection， LinkedList， Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected int	capacityIncrement 量由该载体的容量自动递增时，其大小是大于它的能力。
protected int	elementCount 在这 Vector对象的有效成分的数量。
protected Object[]	elementData 存储向量的组件的数组缓冲区。

Fields inherited from class java.util.AbstractList

modCount

构造方法摘要

构造方法

Constructor and Description
Vector() 构造一个空向量，使其内部数据数组的大小 10及其标准容量增量为零。
Vector(Collection<? extends E> c) 构造一个包含指定集合元素的向量，它们在集合的迭代器返回的顺序中返回。
Vector(int initialCapacity) 用指定的初始容量构造一个空向量，并以其容量增量等于零。
Vector(int initialCapacity, int capacityIncrement) 用指定的初始容量和容量增量构造一个空向量。

方法摘要

Modifier and Type	Method and Description
boolean	add(E e) 将指定的元素，这个矢量的末端。
void	add(int index, E element) 在该向量的指定位置上插入指定的元素。
boolean	addAll(Collection<? extends E> c) 追加指定集合的所有元素的vector中结束，以便他们按指定集合的迭代器返回。
boolean	addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到指定位置的该向量中。
void	addElement(E obj) 添加指定的组件到这个向量的结束，增加其大小由一个。
int	capacity() 返回此向量的当前容量。
void	clear() 从这个向量中移除所有的元素。
Object	clone() 返回此向量的克隆。
boolean	contains(Object o) 返回 true如果这个向量包含指定的元素。
boolean	containsAll(Collection<?> c) 如果此向量包含指定集合中的所有元素，则返回真。
void	copyInto(Object[] anArray) 将此向量的组件复制到指定的数组中。
E	elementAt(int index) 返回指定索引处的组件。
Enumeration<E>	elements() 返回此向量的组件的枚举。
void	ensureCapacity(int minCapacity) 增加此向量的容量，如果必要的话，以确保它至少可以容纳由最小容量参数指定的组件数。
boolean	equals(Object o) 将指定的对象与此向量进行比较，以进行相等性。
E	firstElement() 返回第一个组件（在指数 0项目）这个载体。
void	forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。
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 vector的成员。
boolean	isEmpty() 测试这个向量是否没有组件。
Iterator<E>	iterator() 在这个列表中的元素上返回一个正确的顺序。
E	lastElement() 返回向量的最后一个组件。
int	lastIndexOf(Object o) 返回该向量中指定元素的最后一个发生的索引，或-如果此向量不包含元素，或- 1。
int	lastIndexOf(Object o, int index) 返回这个向量中指定元素的最后一个匹配项的索引，搜索 index往后，或返回1如果元素没有被发现。
ListIterator<E>	listIterator() 返回列表元素的列表迭代器（在适当的顺序）。
ListIterator<E>	listIterator(int index) 在列表中的元素上返回列表迭代器（在适当的顺序），从列表中的指定位置开始。
E	remove(int index) 移除此向量中指定位置的元素。
boolean	remove(Object o) 如果向量不包含元素，则移除该向量中指定元素的第一个情况，它是不变的。
boolean	removeAll(Collection<?> c) 从这个向量中移除包含在指定集合中的所有元素。
void	removeAllElements() 从该向量中移除所有组件，并将其大小设置为零。
boolean	removeElement(Object obj) 从该向量中移除第一个（最低索引）发生的参数。
void	removeElementAt(int index) 在指定的索引中删除组件。
boolean	removeIf(Predicate<? super E> filter) 删除满足给定谓词的这个集合的所有元素。
protected void	removeRange(int fromIndex, int toIndex) 从列表中删除所有的元素的索引 fromIndex之间，包容性，和 toIndex，独家。
void	replaceAll(UnaryOperator<E> operator) 用将运算符应用到该元素的结果替换此列表中的每个元素。
boolean	retainAll(Collection<?> c) 仅保留包含在指定集合中的此向量中的元素。
E	set(int index, E element) 用指定元素替换此向量中指定位置的元素。
void	setElementAt(E obj, int index) 设置组件在指定的 index这个向量是指定的对象。
void	setSize(int newSize) 设置此向量的大小。
int	size() 返回此向量中的组件的数目。
void	sort(Comparator<? super E> c) 分类列表使用提供的 Comparator比较元素。
Spliterator<E>	spliterator() 创建一个后期绑定和快速失败 Spliterator超过此列表中的元素。
List<E>	subList(int fromIndex, int toIndex) 返回一个视图之间的位置，这个清单部分包容，和指数，独家。
Object[]	toArray() 返回包含此向量中的所有元素的数组，以正确的顺序。
<T> T[]	toArray(T[] a) 返回包含此向量中的所有元素的数组，以正确的顺序；返回的数组的运行时类型是指定的数组的运行时类型。
String	toString() 返回此向量的字符串表示形式，包含每个元素的字符串表示形式。
void	trimToSize() 装饰这个向量是向量的电流容量。

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.Collection

parallelStream, stream

Field Detail

elementData

protected Object[] elementData

存储向量的组件的数组缓冲区。该向量的能力是这个数组缓冲区的长度，至少是足够大，以包含所有的向量的元素。

在向量中的最后一个元素后的任何数组元素都是空的。

elementCount

protected int elementCount

在这 Vector对象的有效成分的数量。成分 elementData[0]通过 elementData[elementCount-1]是实际的项目。

capacityIncrement

protected int capacityIncrement

量由该载体的容量自动递增时，其大小是大于它的能力。如果容量增量小于或等于零，该载体的容量是增加一倍，每一个时间，它需要增长。

Constructor Detail

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 -如果指定集合为空

从以下版本开始：

一点二

方法详细信息

copyInto

public void copyInto(Object[] anArray)

将此向量的组件复制到指定的数组中。在这个向量指标 k项目复制到 anArray组件 k。

参数

anArray -阵列的组件被复制

异常

NullPointerException -如果指定数组是空的

IndexOutOfBoundsException -如果指定的数组不足以容纳这个向量的所有组件

ArrayStoreException -如果这个分量不是一个运行时类型可以存储在指定的数组

另请参见：

toArray(Object[])

trimToSize

public void trimToSize()

装饰这个向量是向量的电流容量。如果vector的容量大于当前大小，然后改变产能等于大小通过更换其内部数据数组，存放在现场 elementData，与一个较小的一个。一个应用程序可以使用此操作，以尽量减少存储的向量。

ensureCapacity

public void ensureCapacity(int minCapacity)

增加此向量的容量，如果必要的话，以确保它至少可以容纳由最小容量参数指定的组件数。

如果这个向量的电流容量小于minCapacity，那么它的容量增加了更换其内部数据数组，存放在现场elementData，具有较大的。新数据的数组的大小，将旧的大小加上capacityIncrement，除非capacityIncrement值小于或等于零，在新的能力将两老能力的情况；但如果这个新的规模仍小于minCapacity，那么新的能力将minCapacity。

参数

minCapacity -所需的最小容量

setSize

public void setSize(int newSize)

设置此向量的大小。如果新的尺寸大于当前的大小，新的 null项目添加到vector的末尾。如果新的大小小于当前大小，所有的组件在指数 newSize大被丢弃。

参数

newSize -这个向量的新尺寸

异常

ArrayIndexOutOfBoundsException -如果新的大小负

capacity

public int capacity()

返回此向量的当前容量。

结果

目前的能力（其内部数据数组的长度保持在这个向量场 elementData）

size

public int size()

返回此向量中的组件的数目。

Specified by:

size 接口 Collection<E>

Specified by:

size 接口 List<E>

Specified by:

size 方法重写，继承类 AbstractCollection<E>

结果

此向量中的组件的数目

isEmpty

public boolean isEmpty()

测试这个向量是否没有组件。

Specified by:

isEmpty 接口 Collection<E>

Specified by:

isEmpty 接口 List<E>

重写：

isEmpty 方法重写，继承类 AbstractCollection<E>

结果

true如果vector不成分，即它的大小为零； false否则。

elements

public Enumeration<E> elements()

返回此向量的组件的枚举。返回的 Enumeration对象会产生在这个向量的所有项目。第一项在索引 0生成项目，然后在指数 1项目，等等。

结果

此向量的组件的枚举

另请参见：

Iterator

contains

public boolean contains(Object o)

返回 true如果这个向量包含指定的元素。更正式地说，返回 true当且仅当该载体包含至少一个元素 e这样 (o==null ? e==null : o.equals(e))。

Specified by:

contains 接口 Collection<E>

Specified by:

contains 接口 List<E>

重写：

contains 方法重写，继承类 AbstractCollection<E>

参数

o -这个载体存在的元素进行测试

结果

true如果这个向量包含指定的元素

indexOf

public int indexOf(Object o)

返回该向量中指定元素的第一个出现的索引，或-如果此向量不包含元素，或- 1。更正式地说，返回 i指数最低， (o==null ? get(i)==null : o.equals(get(i)))，或1，如果没有这样的指标。

Specified by:

indexOf 接口 List<E>

重写：

indexOf 方法重写，继承类 AbstractList<E>

参数

o元搜索

结果

该向量中指定元素的第一个发生的索引，或-如果这个向量不包含元素的话，1

indexOf

public int indexOf(Object o,
                   int index)

返回这个向量中第一个出现的指定元素的索引，搜索了从 index，或返回1如果元素没有被发现。更正式地说，返回 i指数最低， (i >= index && (o==null ? get(i)==null : o.equals(get(i))))，或1，如果没有这样的指标。

参数

o元搜索

index指数开始搜索

结果

元素的第一次出现的位置 index或矢量以后在这个矢量的指数； -1如果元素没有被发现。

异常

IndexOutOfBoundsException -如果指定的指数是负的

另请参见：

Object.equals(Object)

lastIndexOf

public int lastIndexOf(Object o)

返回该向量中指定元素的最后一个发生的索引，或-如果此向量不包含元素，或- 1。更正式地说，返回最高指数 i这样 (o==null ? get(i)==null : o.equals(get(i)))，或1，如果没有这样的指标。

Specified by:

lastIndexOf 接口 List<E>

重写：

lastIndexOf 方法重写，继承类 AbstractList<E>

参数

o元搜索

结果

该向量中指定元素的最后一个发生的索引，或-如果这个向量不包含元素的话，1

lastIndexOf

public int lastIndexOf(Object o,
                       int index)

返回这个向量中指定元素的最后一个匹配项的索引，搜索 index往后，或返回1如果元素没有被发现。更正式地说，返回最高指数 i这样 (i <= index && (o==null ? get(i)==null : o.equals(get(i))))，或1，如果没有这样的指标。

参数

o元搜索

index指数开始向后搜索从

结果

在位置小于或等于 index这个向量中的元素最后一次出现的指标；1如果元素没有被发现。

异常

IndexOutOfBoundsException -如果指定的索引大于或等于当前Vector

elementAt

public E elementAt(int index)

返回指定索引处的组件。

这种方法是相同的功能的get(int)方法（是的List接口部分）。

参数

index进入这个向量索引

结果

指定索引中的组件

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index >= size()）

firstElement

public E firstElement()

返回第一个组件（在指数 0项目）这个载体。

结果

该向量的第一个组成部分

异常

NoSuchElementException如果vector没有组件

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。

该指数的值必须大于或等于和小于0矢量电流大小。

这种方法是相同的功能的remove(int)方法（是的List接口部分）。请注意，remove方法返回旧值被存储在指定的位置。

参数

index -对象删除索引

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index >= size()）

insertElementAt

public void insertElementAt(E obj,
                            int index)

将指定的对象在指定的 index vector的成员。用大于或等于指定的 index指数在这个向量的每个分量的向上移动，有一个指数大于先前的价值。

该指数的值必须大于或等于0和小于或等于矢量电流大小。（如果该索引与矢量的当前大小相等，则新的元素被添加到向量。）

这种方法是相同的功能的add(int, E)方法（是的List接口部分）。请注意，add方法反转参数的顺序，以更紧密地匹配的数组的使用。

参数

obj -插入元件

index -如何插入新的组件

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index > size()）

addElement

public void addElement(E obj)

添加指定的组件到这个向量的结束，增加其大小由一个。该载体的容量增加，如果它的大小变得大于它的容量。

这种方法是相同的功能的add(E)方法（是的List接口部分）。

参数

obj -要添加的组件

removeElement

public boolean removeElement(Object obj)

从该向量中移除第一个（最低索引）发生的参数。如果在这个向量中发现的对象，每个组件在向量与一个指数更大或等于对象的指数向下转移有一个指数比它以前所拥有的价值。

这种方法是相同的功能的remove(Object)方法（是的List接口部分）。

参数

obj -要移除的组件

结果

true如果参数是这个向量的分量； false否则。

removeAllElements

public void removeAllElements()

从该向量中移除所有组件，并将其大小设置为零。

这种方法是相同的功能的clear()方法（是的List接口部分）。

clone

public Object clone()

返回此向量的克隆。的副本将包含一个指向内部数据数组克隆的，不是指这个 Vector原始物体内部数据数组。

重写：

clone 方法重写，继承类 Object

结果

这种载体的克隆

另请参见：

Cloneable

toArray

public Object[] toArray()

返回包含此向量中的所有元素的数组，以正确的顺序。

Specified by:

toArray 接口 Collection<E>

Specified by:

toArray 接口 List<E>

重写：

toArray 方法重写，继承类 AbstractCollection<E>

结果

包含在这个集合中的所有元素的数组

从以下版本开始：

一点二

另请参见：

Arrays.asList(Object[])

toArray

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

返回包含此向量中的所有元素的数组，以正确的顺序；返回的数组的运行时类型是指定的数组的运行时类型。如果向量适合在指定的数组中，它返回其中。否则，一个新的数组被分配与指定的数组的运行时类型和该向量的大小。

如果向量适合在指定的数组与空间的空闲（即，数组有更多的元素比向量），在数组中的元素立即结束后的向量被设置为空。（这是有用的，在确定的向量的长度，只有当来电者知道，向量不包含任何空元素。）

Specified by:

toArray 接口 Collection<E>

Specified by:

toArray 接口 List<E>

重写：

toArray 方法重写，继承类 AbstractCollection<E>

参数类型

T -数组的运行时类型包含集合

参数

a -为向量的元素保存到数组，如果它足够大；否则，一个新的运行时类型相同的数组分配给这个目的。

结果

包含向量元素的数组

异常

ArrayStoreException -如果一个运行时类型不是一个类型的vector中每个元素运行时类型

NullPointerException -如果指定数组是空的

从以下版本开始：

一点二

get

public E get(int index)

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

Specified by:

get 接口 List<E>

Specified by:

get 方法重写，继承类 AbstractList<E>

参数

index索引元素的回归

结果

在指定索引中的对象

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index >= size()）

从以下版本开始：

一点二

set

public E set(int index,
             E element)

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

Specified by:

set 接口 List<E>

重写：

set 方法重写，继承类 AbstractList<E>

参数

index索引的元素代替

element元素被存储在指定的位置

结果

先前在指定位置的元素

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index >= size()）

从以下版本开始：

一点二

add

public boolean add(E e)

将指定的元素，这个矢量的末端。

Specified by:

add 接口 Collection<E>

Specified by:

add 接口 List<E>

重写：

add 方法重写，继承类 AbstractList<E>

参数

e元被附加到这个向量

结果

true（由 Collection.add(E)指定）

从以下版本开始：

一点二

remove

public boolean remove(Object o)

如果向量不包含元素，则移除该向量中指定元素的第一个情况，它是不变的。更正式，移除元素的最低指标（如我这样的 (o==null ? get(i)==null : o.equals(get(i)))元素存在）。

Specified by:

remove 接口 Collection<E>

Specified by:

remove 接口 List<E>

重写：

remove 方法重写，继承类 AbstractCollection<E>

参数

o元是从这个载体的删除，如果存在

结果

如果包含指定元素的向量，则是真的

从以下版本开始：

一点二

add

public void add(int index,
                E element)

在该向量的指定位置上插入指定的元素。将当前处于该位置（如果有的话）和任何后续元素的元素移到右边（添加一个到它们的索引）。

Specified by:

add 接口 List<E>

重写：

add 方法重写，继承类 AbstractList<E>

参数

index指数在指定的元素被插入

element元素被插入

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index > size()）

从以下版本开始：

一点二

remove

public E remove(int index)

移除此向量中指定位置的元素。所有后续元素左移（下标减1）。返回从向量中删除的元素。

Specified by:

remove 接口 List<E>

重写：

remove 方法重写，继承类 AbstractList<E>

参数

index -要被删除的元素的索引

结果

移除的元素

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index >= size()）

从以下版本开始：

一点二

clear

public void clear()

从这个向量中移除所有的元素。该向量将是空的，这个调用返回后（除非它抛出一个例外）。

Specified by:

clear 接口 Collection<E>

Specified by:

clear 接口 List<E>

重写：

clear 方法重写，继承类 AbstractList<E>

从以下版本开始：

一点二

containsAll

public boolean containsAll(Collection<?> c)

如果此向量包含指定集合中的所有元素，则返回真。

Specified by:

containsAll 接口 Collection<E>

Specified by:

containsAll 接口 List<E>

重写：

containsAll 方法重写，继承类 AbstractCollection<E>

参数

c -一个集合的元素将被测试在这个矢量控制

结果

如果此向量包含指定集合中的所有元素，则为真

异常

NullPointerException -如果指定集合为空

另请参见：

AbstractCollection.contains(Object)

addAll

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

追加指定集合的所有元素的vector中结束，以便他们按指定集合的迭代器返回。当操作正在进行中时，此操作的行为是未定义的，如果指定的集合被修改，则该操作将被修改为。（这意味着这个电话的行为是未定义的如果指定集合向量，这个向量是空的。）

Specified by:

addAll 接口 Collection<E>

Specified by:

addAll 接口 List<E>

重写：

addAll 方法重写，继承类 AbstractCollection<E>

参数

c元素被插入该载体

结果

true如果调用的结果向量改变

异常

NullPointerException -如果指定集合为空

从以下版本开始：

一点二

另请参见：

AbstractCollection.add(Object)

removeAll

public boolean removeAll(Collection<?> c)

从这个向量中移除包含在指定集合中的所有元素。

Specified by:

removeAll 接口 Collection<E>

Specified by:

removeAll 接口 List<E>

重写：

removeAll 方法重写，继承类 AbstractCollection<E>

参数

c -元素集合可以从向量中除去

结果

如果此向量更改为调用的结果，则为

异常

ClassCastException如果vector中一个或多个元素的类型与指定集合不相容（ optional）

NullPointerException -如果该载体包含一个或多个null元素而指定集合不支持null元素（ optional），或者指定集合为空

从以下版本开始：

一点二

另请参见：

AbstractCollection.remove(Object)， AbstractCollection.contains(Object)

retainAll

public boolean retainAll(Collection<?> c)

仅保留包含在指定集合中的此向量中的元素。换句话说，从这个向量中移除所有不包含在指定集合中的元素。

Specified by:

retainAll 接口 Collection<E>

Specified by:

retainAll 接口 List<E>

重写：

retainAll 方法重写，继承类 AbstractCollection<E>

参数

c -元素集合中要保留的载体（所有其他的元素被删除）

结果

如果此向量更改为调用的结果，则为

异常

ClassCastException如果vector中一个或多个元素的类型与指定集合不相容（ optional）

NullPointerException -如果该载体包含一个或多个null元素而指定集合不支持null元素（ optional），或者指定集合为空

从以下版本开始：

一点二

另请参见：

AbstractCollection.remove(Object)， AbstractCollection.contains(Object)

addAll

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

将指定集合中的所有元素插入到指定位置的该向量中。将当前处于该位置（如果有的话）和任何后续元素的元素移到右边（增加它们的索引）。新的元素将出现在由指定集合的迭代器返回的向量中的向量中。

Specified by:

addAll 接口 List<E>

重写：

addAll 方法重写，继承类 AbstractList<E>

参数

index指数，从指定集合的第一个元素的插入

c元素被插入该载体

结果

true如果调用的结果向量改变

异常

ArrayIndexOutOfBoundsException如果索引超出范围（ index < 0 || index > size()）

NullPointerException -如果指定集合为空

从以下版本开始：

一点二

equals

public boolean equals(Object o)

将指定的对象与此向量进行比较，以进行相等性。返回真，如果只有当指定的对象也是一个列表，两个列表有相同的大小，以及两个列表中的所有对应的元素对都是相等的。（如果 (e1==null ? e2==null : e1.equals(e2))。两元素 e1和 e2相等）换句话说，两个列表的定义就包含在同一顺序相同的元素。

Specified by:

equals 接口 Collection<E>

Specified by:

equals 接口 List<E>

重写：

equals 方法重写，继承类 AbstractList<E>

参数

o要比较这个向量相等的对象

结果

如果指定的对象等于该向量，则为真

另请参见：

Object.hashCode()， HashMap

hashCode

public int hashCode()

返回此向量的哈希代码值。

Specified by:

hashCode 接口 Collection<E>

Specified by:

hashCode 接口 List<E>

重写：

hashCode 方法重写，继承类 AbstractList<E>

结果

此列表的哈希代码值

另请参见：

Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)

toString

public String toString()

返回此向量的字符串表示形式，包含每个元素的字符串表示形式。

重写：

toString 方法重写，继承类 AbstractCollection<E>

结果

此集合的字符串表示

subList

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

返回一个视图之间的位置，这个清单部分包容，和指数，独家。（如果从指标和指数相等，返回的列表是空的。）返回的列表是通过这个列表的支持，所以在返回列表中的变化反映在这个列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。

此方法消除了对显式范围操作（通常用于数组的排序）的需要。任何希望将列表作为一个范围操作的操作子列表视图而不是整个列表。例如，下面的成语从列表中移除了一系列元素：

列表。列表（从，到clear()）；

相似的习语可以构建指标和字符串，和集合中的所有类的算法可以应用到列表。

列表的语义，该方法返回的是如果支持列表（即，这个列表）是通过返回的列表结构改性以外的其他任何方式。（结构上的修改是指改变列表、大小或其他方式，迭代的进展可能会产生不正确的结果。）

Specified by:

subList 接口 List<E>

重写：

subList 方法重写，继承类 AbstractList<E>

参数

fromIndex低端点（含）的子列表

toIndex高端点（独家）的子列表

结果

此列表中指定范围的视图

异常

IndexOutOfBoundsException -如果一个端点索引值超出范围 (fromIndex < 0 || toIndex > size)

IllegalArgumentException如果终点指标是为了 (fromIndex > toIndex)

removeRange

protected void removeRange(int fromIndex,
                           int toIndex)

从列表中删除所有的元素的索引 fromIndex之间，包容性，和 toIndex，独家。将任何成功的元素转移到左边（降低它们的索引）。这叫缩短列表 (toIndex - fromIndex)元素。（如果 toIndex==fromIndex，此操作没有影响。）

重写：

removeRange 方法重写，继承类 AbstractList<E>

参数

fromIndex -第一个元素被删除索引

toIndex -要删除的最后一个元素后的指标

listIterator

public ListIterator<E> listIterator(int index)

在列表中的元素上返回列表迭代器（在适当的顺序），从列表中的指定位置开始。指定的索引显示的第一个元素，将由 next初始调用返回， previous初始调用将返回与指定的指数减一元。

返回的列表迭代器是fail-fast。

Specified by:

listIterator 接口 List<E>

重写：

listIterator 方法重写，继承类 AbstractList<E>

参数

index索引的第一个元素是列表迭代器返回（通过调用 next）

结果

列表中元素的列表迭代器（在适当的顺序），从列表中的指定位置开始

异常

IndexOutOfBoundsException如果索引超出范围（ index < 0 || index > size()）

listIterator

public ListIterator<E> listIterator()

返回列表元素的列表迭代器（在适当的顺序）。

返回的列表迭代器是fail-fast。

Specified by:

listIterator 接口 List<E>

重写：

listIterator 方法重写，继承类 AbstractList<E>

结果

列表中元素的列表迭代器（在适当的顺序）

另请参见：

listIterator(int)

iterator

public Iterator<E> iterator()

在这个列表中的元素上返回一个正确的顺序。

返回的迭代器是fail-fast。

Specified by:

iterator 接口 Iterable<E>

Specified by:

iterator 接口 Collection<E>

Specified by:

iterator 接口 List<E>

重写：

iterator 方法重写，继承类 AbstractList<E>

结果

在这个列表中的元素的迭代器在适当的顺序

forEach

public void forEach(Consumer<? super E> action)

从接口复制的描述： Iterable

执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。除非实现类的其他指定，否则操作在迭代的顺序中（如果指定了一个迭代顺序）。由操作引发的异常被传递给调用方。

Specified by:

forEach 接口 Iterable<E>

参数

action -是的每个元素执行的动作

removeIf

public boolean removeIf(Predicate<? super E> filter)

从接口复制的描述： Collection

删除满足给定谓词的这个集合的所有元素。在迭代过程中或谓词所引发的错误或运行时异常被传递给调用方。

Specified by:

removeIf 接口 Collection<E>

参数

filter -谓词返回的元素被删除 true

结果

true如果任何被删除元素

replaceAll

public void replaceAll(UnaryOperator<E> operator)

从接口复制的描述： List

用将运算符应用到该元素的结果替换此列表中的每个元素。由操作员抛出的错误或运行时异常被传递给调用方。

Specified by:

replaceAll 接口 List<E>

参数

operator -操作适用于每一个元素

sort

public void sort(Comparator<? super E> c)

从接口复制的描述： List

分类列表使用提供的 Comparator比较元素。

Specified by:

sort 接口 List<E>

参数

c用来比较列表元素的 Comparator。一个 null值表示元素的 natural ordering应使用

spliterator

public Spliterator<E> spliterator()

创建一个后期绑定和快速失败 Spliterator超过此列表中的元素。

报告的Spliterator Spliterator.SIZED，Spliterator.SUBSIZED，和Spliterator.ORDERED。重写实现应记录附加特征值的报告。

Specified by:

spliterator 接口 Iterable<E>

Specified by:

spliterator 接口 Collection<E>

Specified by:

spliterator 接口 List<E>

结果

在列表中的元素的 Spliterator

从以下版本开始：

一点八