javatm platform
standard ed. 6

java.util
类 vector<e>

java.lang.object 继承者 java.util.abstractcollection<e> 继承者 java.util.abstractlist<e>   继承者 java.util.vector<e>
所有<suǒ yǒu>已实现的接口:
serializable, cloneable, iterable<e>, collection<e>, list<e>, randomaccess
直接已知子类:
stack

public class vector<e>
extends abstractlist<e>
implements list<e>, randomaccess, cloneable, serializable

vector 类可以<can>实现可增长的对象数组。与数组一样,它包含可以<can>使用整数索引进行访问<fǎng wèn>的组件。但是<But>,vector 的大小可以根据需要增大或缩小,以适应创建 vector 后进行添加或移除项的操作。

每个向量会试图通过维护 capacitycapacityincrement 来优化存储管理<managing>。capacity 始终至少应与向量的大小相等;这个值通常比后者大些,因为随着<Along with>将组件添加到向量中,其存储将按 capacityincrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量;这样<then>就减少了增加的重分配的量。

由 vector 的 iterator 和 listiterator 方法所返回的迭代器是快速失败的:如果在迭代器创建后的任意时间从结构上修改了向量(通过迭代器自身的 remove 或 add 方法之外的任何其他<other>方式),则迭代器将抛出 concurrentmodificationexception。因此<therefore>,面对并发的修改,迭代器很快就完全<wán quán>失败,而不是冒着在将来不确定的时间任意发生<occasionally occurred>不确定行为的风险。vector 的 elements 方法返回的 enumeration 不是 快速失败的。

注意<zhù yì>,迭代器的快速失败行为不能得到保证,一般来说,存在不同步的并发修改时,不可能<kě néng>作出任何坚决的保证。快速失败迭代器尽最大<largest>努力抛出 concurrentmodificationexception。因此<therefore>,编写依赖于此异常的程序的方式是错误的,正确做法是:迭代器的快速失败行为应该<yīng gāi>仅用于检测 bug。

从 java 2 平台 v1.2 开始<appeared>,此类改进为可以实现 list 接口,使它成为<chéng wéi> javacollections framework 的成员。与新 collection 实现不同,vector 是同步的。

从以下版本开始<appeared>:
jdk1.0
另请参见:
collection,list,arraylist,linkedlist,序列化表格

字段摘要
protected  intcapacityincrement
          向量的大小大于其容量时,容量自动增加的量。
protected  intelementcount
          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)
          使用指定的初始容量和容量增量构造一个空的向量。
 
方法摘要
 booleanadd(e e)
          将指定元素添加到此向量的末尾。
 voidadd(int index,e element)
          在此向量的指定位置<locates>插入指定的元素。
 booleanaddall(collection<? extends e> c)
          将指定 collection 中的所有元素添加到此向量的末尾,按照指定 collection 的迭代器所返回的顺序添加这些元素。
 booleanaddall(int index,collection<? extends e> c)
          在指定位置<locates>将指定 collection 中的所有元素插入到此向量中。
 voidaddelement(e obj)
          将指定的组件添加到此向量的末尾,将其大小增加 1。
 intcapacity()
          返回此向量的当前容量。
 voidclear()
          从此向量中移除所有元素。
 objectclone()
          返回向量的一个副本。
 booleancontains(object o)
          如果此向量包含指定的元素,则返回 true
 booleancontainsall(collection<?> c)
          如果此向量包含指定 collection 中的所有元素,则返回 true。
 voidcopyinto(object[] anarray)
          将此向量的组件复制到指定的数组中。
 eelementat(int index)
          返回指定索引处的组件。
 enumeration<e>elements()
          返回此向量的组件的枚举。
 voidensurecapacity(int mincapacity)
          增加此向量的容量(如有必要),以确保其至少能够保存最小<smallest>容量参数指定的组件数。
 booleanequals(object o)
          比较指定对象与此向量的相等性。
 efirstelement()
          返回此向量的第一个组件(位于索引 0) 处的项)。
 eget(int index)
          返回向量中指定位置的元素。
 inthashcode()
          返回此向量的哈希码值。
 intindexof(object o)
          返回此向量中第一次出现<There>的指定元素的索引,如果此向量不包含该元素,则返回 -1。
 intindexof(object o,int index)
          返回此向量中第一次出现<There>的指定元素的索引,从 index 处正向搜索,如果未找到该元素,则返回 -1。
 voidinsertelementat(e obj,int index)
          将指定对象作为此向量中的组件插入到指定的 index 处。
 booleanisempty()
          测试此向量是否不包含组件。
 elastelement()
          返回此向量的最后一个组件。
 intlastindexof(object o)
          返回此向量中最后一次出现的指定元素的索引;如果此向量不包含该元素,则返回 -1。
 intlastindexof(object o,int index)
          返回此向量中最后一次出现的指定元素的索引,从 index 处逆向搜索,如果未找到该元素,则返回 -1。
 eremove(int index)
          移除此向量中指定位置的元素。
 booleanremove(object o)
          移除此向量中指定元素的第一个匹配项,如果向量不包含该元素,则元素保持不变。
 booleanremoveall(collection<?> c)
          从此向量中移除包含在指定 collection 中的所有元素。
 voidremoveallelements()
          从此向量中移除全部<all>组件,并将其大小设置为零。
 booleanremoveelement(object obj)
          从此向量中移除变量的第一个(索引最小<smallest>的)匹配项。
 voidremoveelementatjs随机数(int index)
          删除指定索引处的组件。
protected  voidremoverange(int fromindex,int toindex)
          从此 list 中移除其索引位于 fromindex(包括<bāo kuò>)与 toindex(不包括<bāo kuò>)之间的所有元素。
 booleanretainall(collection<?> c)
          在此向量中仅保留包含在指定 collection 中的元素。
 eset(int index,e element)
          用指定的元素替换此向量中指定位置处的元素。
 voidsetelementat(e obj,int index)
          将此向量指定 index 处的组件设置为指定的对象。
 voidsetsize(int newsize)
          设置此向量的大小。
 intsize()
          返回此向量中的组件数。
 list<e>sublist(int fromindex,int toindex)
          返回此 list 的部分视图,元素范围为从 fromindex(包括)到 toindex(不包括)。
 object[]toarray()
          返回一个数组,包含此向量中以恰当顺序存放的所有元素。
<t> t[]
toarray(t[] a)
          返回一个数组,包含此向量中以恰当顺序存放的所有元素;返回数组的运行时类型为指定数组的类型。
 stringtostring()
          返回此向量的字符串表示形式,其中包含每个元素的 string 表示形式。
 voidtrimtosize()
          对此向量的容量进行微调,使其等于向量的当前大小。
 
从类 java.util.abstractlist 继承的方法
iterator, listiterator, listiterator
 
从类 java.lang.object 继承的方法
finalize, getclass, notify, notifyall, wait, wait, wait
 
从接口 java.util.list 继承的方法
iterator, listiterator, listiterator
 

字段详细校糶ǎn>畔

elementdata

protected object[] elementdata
存储向量组件的数组缓冲区。vector 的容量就是此数据缓冲区的长度< dù>,该长度< dù>至少要足以包含向量的所有元素。

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。更确切地讲,当且仅当此向量至少包含一个满足<mǎn zú> (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。更确切地讲,返回满足<mǎn zú> (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i;如果没有这样<then>的索引,则返回 -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
原则上,正职员工超过300人的日本<吃屎的国家>企业<business>,首度雇用外籍实习生时的录用名额,不能超过总员工数的5%,无法<to be>说增加就增加
目前,许多<xǔ duō>旅游<travel>网站都会根据消费者过去使用的数据,来提供折扣或推荐行程,脸书和Google等网站也会?L集使用者的喜好或地点等资料,藉此推销适当的广告
一间夜店推出克利福德的表演,还放上她与川普合照,但并未提到川普名字
尤其随着<Along with>今年将会员APP优化之后推出会员绑定APP即送50元还元金,提高消费者加入会员APP的意愿,使得光今年短短2周的时间绑定APP的会员数即超越去年下半年的绑定数量
除了中国<zhōng guó>与俄罗斯,文件中提及,北韩也是国防部的首要问题<foul-ups>,需要加强飞弹防御系统,来对抗北韩的核子武器,以及各种生化武力,另外也有提到伊朗的暴力、恐怖主义等对和平造成威胁
全球最大<largest>的成人影音网站Pornhub成立<chéng lì>10周年,特地?u作了2017年用户使用调查报告,其中台湾<中国台湾省>地区的报告显示,搜寻度最高的关键字是
县府表示,徐耀昌一上任就为财政南北奔波、为县政东奔西跑,3年来光是座车就跑了超过23万余公里,
补助案,应透过申请,台中市文化局计划<plan>书都还未送到文化部,李连权就承诺要补助1000万元,是
<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) 方法的功能完全<wán quán>相同(后者是 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 接口的一部分)。注意<zhù yì>,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()
从此向量中移除全部<all>组件,并将其大小设置为零。

此方法的功能与 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)
返回一个数组,包含此向量中以恰当顺序存放的所有元素;返回数组的运行时类型为指定数组的类型。如果向量能够适应指定的数组,则返回该数组。否则使用此数组的运行时类型和此向量的大小分配一个新数组。

如果向量能够适应指定的数组,而且<but>还有多余空间(即数组的元素比向量的元素多),则将紧跟向量末尾的数组元素设置为 null。( 在调用者知道<zhī dao>向量不包含任何 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 removejs随机数(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 - 要插入到此向量的元素
返回:
如果此向量由于<Meanwhile>调用而更改,则返回 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
返回:
如果此向量由于<Meanwhile>调用而更改,则返回 true
抛出:
classcastexception - 如果此向量中的一个或多个元素的类型与指定 collection 不兼容(可选)
nullpointerexception - 如果此向量包含一个或多个 null 元素并且指定 collection 不支持<zhī chí> 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(移除其他<other>所有元素)
返回:
如果此向量由于调用而更改,则返回 true
抛出:
classcastexception - 如果此向量中的一个或多个元素的类型与指定 collection 不兼容(可选)
nullpointerexception - 如果此向量包含一个或多个 null 元素并且指定 collection 不支持<zhī chí> 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)),则两个元素 e1e2 相等)。换句话说,如果两个 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 构造类似的语句,而且<but> 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 - 要移除的最后一个元素之后的索引

javatm platform
standard ed. 6

提交错误或意见<yì jian>
有关更多的 api 参考资料和开发<kāi fā>人员文档,请参阅 java se 开发<kāi fā>人员文档。该文档包含更详细的、面向开发人员的描述,以及总体概述、术语定义、使用技巧和工作<gōng zuò>代码示例。

版权所有 2007 sun microsystems, inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策