首先我们来看看API中对Vector的描述。
| +----java.util.Vector
public class Vector
extends Object
implements Cloneable, Serializable
下列类的父类：
Vector 类实现了可动态扩充的对象数组。类似数组，它包含的元素可通过数组下标来访问。但是，在 Vector 创建之后。Vector 可根据增加和删除元素的需要来扩大或缩小。
每个向量可通过维护
capacity 和 capacityIncrement 来优化存储空间的管理。capacity 至少和向量大小一样大；但它通常会更大些，因为向量会添加组件，向量的存储空间会根据
capacityIncrement 增加。应用在插入大数量的组件之前会增加向量的容量；这减少了再分配的数量。
变量索引
当向量的大小超过它的容量时的向量容量的自动增加量。
向量中的有效元素数。
存储向量中元素的数组缓冲区。
构造子索引
方法索引
addElement(Object)
在向量尾部添加一个指定组件，并把它的长度加一。
capacity()
返回当前向量的容量。
clone()
返回该向量的一个 clone 。
contains(Object)
测试指定对象是否该向量的一个元素。
copyInto(Object[])
把该向量的元素复制到指定数组中。
elementAt(int)
返回指定下标处的组件。
elements()
返回该向量的元素的一个枚举。
ensureCapacity(int)
增加向量容量，必要的话，保证它至少能容纳由最小容量参数指定的组件数。
返回该向量的第一个元素。
indexOf(Object)
查找给定参数在向量中第一次出现的位置，并用
equals方法测试它们是否相等。indexOf(Object, int)
从
index处开始查找给定参数在向量中第一次出现的位置，并用equals方法测试它们是否相等。insertElementAt(Object, int)
在指定的
index处插入作为该向量元素的指定对象。isEmpty()
测试该向量是否无元素。
返回向量的最后一个元素。
lastIndexOf(Object)
返回向量中最后出现的指定对象的下标。
lastIndexOf(Object, int)
从指定的下标向后查找指定的对象，并返回它的下标。
删除向量的所有元素并把它的大小置为零。
removeElement(Object)
从向量中删除第一个出现的参数。
removeElementAt(int)
删除指定下标处的元素。
setElementAt(Object, int)
设置在向量中指定的
index处的元素为指定的对象。setSize(int)
设置向量的大小。
size()
返回该向量的元素数。
toString()
返回该向量的字符串表示。
把该向量的容量调整为向量的当前大小。
变量
protected Object elementData[]
存储向量中的元素的数组缓冲区。向量的容量就是该数组缓冲区的长度。
protected int elementCount
向量中的有效元素数。
protected int capacityIncrement
当向量大小超过它的容量时的向量容量的自动增加量。如果容量增量为
0, 向量的容量在每次需要增加时会扩充一倍。
构造子
public Vector(int initialCapacity, int capacityIncrement)
用指定的初始化容量和容量增量构造一个空向量。
参数：
initialCapacity - 向量的初始容量。
capacityIncrement - 当向量溢出时容量的增长量。
public Vector(int initialCapacity)
用指定的初始化容量构造一个空向量。
参数：
initialCapacity - 向量的初始容量。
public Vector()
构造一个空向量。
方法
public final synchronized void copyInto(Object anArray[])
把该向量的元素复制到指定数组中。 数组必须足够大到可容纳向量中的所有对象。
参数：
anArray - 放复制元素的数组。
public final synchronized void trimToSize()
把该向量的容量调整为向量的当前大小。应用可使用该操作最小化向量存储空间。
public final synchronized void ensureCapacity(int minCapacity)
增加向量容量，必要的话，保证它至少能容纳由最小容量参数指定的组件数。
参数：
minCapacity - 要求的最小容量。
public final synchronized void setSize(int newSize)
设置向量的大小。 如果新大小大于当前大小，则新的
null项添加到向量尾部。如果新的大小小于当前大小，所有下标大于或等于newSize的元素将被抛弃。参数：
newSize - 向量的新大小。
public final int capacity()
返回该向量的当前容量。
返回值：
该向量的当前容量。
public final int size()
返回该向量的元素数。
返回值：
该向量的元素数。
public final boolean isEmpty()
测试该向量是否无元素。
返回值：
如果该向量无元素，返回
true；反之返回false。
public final synchronized Enumeration elements()
返回该向量的元素的一个枚举。
返回值：
该向量的元素的一个枚举。
参见：
public final boolean contains(Object elem)
测试指定对象是该向量的一个元素。
参数：
elem - 一个对象。
返回值：
如果指定对象是该向量中的一个元素，则返回
true；否则返回false。
public final int indexOf(Object elem)
查找给定参数在向量中第一次出现的位置，并用
equals方法测试它们是否相等。参数：
elem - 一个对象。
返回值：
参数在向量中第一次出现处的下标；如果该对象未找到，则返回
-1。参见：
public final synchronized int indexOf(Object elem, int index)
从
index处开始查找给定参数在向量中第一次出现的位置，并用equals方法测试它们是否相等。参数：
elem - 一个对象。
index - 开始查找的位置的下标。
返回值：
参数在向量中的
index处或在它之后第一次出现的位置的下标；如果该对象未找到，则返回-1。参见：
public final int lastIndexOf(Object elem)
返回向量中最后出现的指定对象的下标。
参数：
elem - 指定的元素。
返回值：
指定对象在向量中最后一次出现处的下标；如果该对象未找到，则返回
-1。
public final synchronized int lastIndexOf(Object elem, int index)
从指定的下标向后查找指定的对象，并返回它的下标。
参数：
elem - 指定的元素。
index - 开始查找的位置的下标。
返回值：
指定对象在向量中的
index处或在它之后第一次出现的位置的下标；如果该对象未找到，则返回-1。
public final synchronized Object elementAt(int index)
返回指定下标处的组件。
参数：
index - 向量中的一个下标。
返回值：
指定下标处的元素。
如果给出无效的下标。
public final synchronized Object firstElement()
返回该向量的第一个元素。
返回值：
该向量的第一个元素。
如果该向量没有元素。
public final synchronized Object lastElement()
返回向量的最后一个元素。
返回值：
向量的最后一个元素，即在下标
size() - 1处的元素。如果该向量为空。
public final synchronized void setElementAt(Object obj, int index)
设置在向量中指定的
index处的元素为指定的对象。 在该位置的先前元素被抛弃。下标值必须大于或等于
0，并且小于向量的当前大小。参数：
obj - 元素被设置成的那个对象。
index - 指定下标。
如果下标无效。
参见：
public final synchronized void removeElementAt(int index)
删除指定下标处的元素。 在该向量中下标大于或等于
index的元素的下标值减一。下标值必须大于或等于
0，并且小于向量的当前大小。参数：
index - 要删除对象的下标。
如果下标无效。
参见：
public final synchronized void insertElementAt(Object obj, int index)
在指定的
index处插入作为该向量元素的指定对象。 在该向量中下标大于或等于index的元素的下标值加一。下标值必须大于或等于
0，并且小于或等于向量的当前大小。参数：
obj - 要插入的元素
index - 插入新元素的位置。
如果下标无效。
参见：
public final synchronized void addElement(Object obj)
在向量尾部添加一个指定组件，并把它的长度加一。 当向量大小超过它的容量时向量的容量自动增加。
参数：
obj - 要添加的元素。
public final synchronized boolean removeElement(Object obj)
从向量中删除第一个出现的参数。 如果在向量中找到该对象，在该向量中下标大于或等于
index的每个元素的下标值减一。参数：
obj - 要删除的元素。
返回值：
如果参数是向量的一个元素，返回
true；否则返回false。
public final synchronized void removeAllElements()
删除向量的所有元素并把它的大小置为零。
public synchronized Object clone()
public final synchronized String toString()
以上的这些是在API中看到的。 Vector 类提供了实现可增长数组的功能，随着更多元素加入其中，数组变的更大。在删除一些元素之后，数组变小。
Vector 有三个构造函数：
public Vector(int initialCapacity,int capacityIncrement)
public Vector(int initialCapacity)
public Vector()
Vector 运行时创建一个初始的存储容量initialCapacity，存储容量是以capacityIncrement 变量定义的增量增长。初始的存储容量和capacityIncrement 可以在Vector 的构造函数中定义。第二个构造函数只创建初始存储容量。第三个构造函数既不指定初始的存储容量也不指定capacityIncrement。
Vector 类提供的访问方法支持类似数组运算和与Vector 大小相关的运算。类似数组的运算允许向量中增加，删除和插入元素。它们也允许测试矢量的内容和检索指定的元素，与大小相关的运算允许判定字节大小和矢量中元素的数目。
现针对经常用到的对向量增，删，插功能举例描述：
addElement(Object obj)
把组件加到向量尾部，同时大小加1，向量容量比以前大1
insertElementAt(Object obj, int index)
把组件加到所定索引处，此后的内容向后移动1 个单位
setElementAt(Object obj, int index)
把组件加到所定索引处，此处的内容被代替。
removeElement(Object obj) 把向量中含有本组件内容移走。
removeAllElements() 把向量中所有组件移走，向量大小为0。
例如：
import java.lang.System;
import java.util.Vector;
import java.util.Emumeration;
public class Avector{
public static void main(String args[]){
Vector v=new Vector();
v.addElement("one");
v.addElement("two");
v.addElement("three");
v.insertElementAt("zero",0);
v.insertElementAt("oop",3);
v.setElementAt("three",3);
v.setElementAt("four",4);
v.removeAllElements();
}
}Vector中的变化情况：
1. one 2. one 3. one 4. zero 5. zero 6. zero 7. zero
two two one one one one
three two two two two
three oop three three
three three four
Vector 可实现自动增长的对象数组。
java.util.vector提供了向量类(vector)以实现类似动态数组的功能。在Java语言中没有指针的概念，但如果正确灵活地使用指针又确实可以大大提高程序的质量。比如在c,c++中所谓的“动态数组”一般都由指针来实现。为了弥补这个缺点，Java提供了丰富的类库来方便编程者使用，vector类便是其中之一。事实上，灵活使用数组也可以完成向量类的功能，但向量类中提供大量的方法大大方便了用户的使用。
创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况。可以考虑使用向量类。
向量类提供了三种构造方法：
public vector() public vector(int initialcapacity,int capacityIncrement) public vector(int initialcapacity)
使用第一种方法系统会自动对向量进行管理，若使用后两种方法。则系统将根据参数，initialcapacity设定向量对象的容量(即向量对象可存储数据的大小)，当真正存放的数据个数超过容量时。系统会扩充向量对象存储容量。
参数capacityincrement给定了每次扩充的扩充值。当capacityincrement为0的时候，则没次扩充一倍，利用这个功能可以优化存储。在Vector类中提供了各种方法方便用户的使用：
插入功能：
(1)public final synchronized void adddElement(Object obj)
将obj插入向量的尾部。obj可以是任何类型的对象。对同一个向量对象，亦可以在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数组转换成相应的对象。
例如：要插入整数1时，不要直接调用v1.addElement(1),正确的方法为：
Vector v1 = new Vector();
Integer integer1 = new Integer(1);
v1.addElement(integer1);
(2)public final synchronized void setElementAt(Object obj,int index)
将index处的对象设置成obj，原来的对象将被覆盖。
(3)public final synchronized void insertElement(Object obj,int index)
在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。
删除功能：
(1)public final synchronized void removeElement(Object obj)
从向量中删除obj,若有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。
(2)public final synchronized void removeAllElement();
删除向量所有的对象
(3)public fianl synchronized void removeElementAt(int index)
删除index所指的地方的对象
查询搜索功能：
(1)public final int indexOf(Object obj)
从向量头开始搜索obj,返回所遇到的第一个obj对应的下标，若不存在此obj,返回-1.
(2)public final synchronized int indexOf(Object obj,int index)
从index所表示的下标处开始搜索obj.
(3)public final int lastindexOf(Object obj)
从向量尾部开始逆向搜索obj.
(4)public final synchornized int lastIndex(Object obj,int index)
从index所表示的下标处由尾至头逆向搜索obj.
(5)public final synchornized firstElement()
获取向量对象中的首个obj
(6)public final synchornized Object lastElement()
获取向量对象的最后一个obj
例子：VectorApp.java
import java.util.Vector;
import java.lang.*;
import java.util.Enumeration;
public class VectorApp
{
public static void main(String args[])
{
Vector v1 = new Vector();
Integer integer1= new Integer(1);
//加入为字符串对象
v1.addElement("one");
//加入的为integer的对象
v1.addElement(integer1);
v1.addElement(integer1);
v1.addElement("two");
v1.addElement(new Integer(2));
v1.addElement(integer1);
v1.addElement(integer1);
//转为字符串并打印
System.out.println("The Vector v1 is:\n\t"+v1);
//向指定位置插入新对象
v1.insertElement("three",2);
v1.insertElement(new Float(3.9),3);
System.out.println("The Vector v1(used method
insertElementAt()is:\n\t)"+v1);
//将指定位置的对象设置为新的对象
//指定位置后的对象依次往后顺延
v1.setElementAt("four",2);
System.out.println("The vector v1 cused method
setElmentAt()is:\n\t"+v1);
v1.removeElement(integer1);
//从向量对象v1中删除对象integer1
//由于存在多个integer1,所以从头开始。
//找删除找到的第一个integer1.
Enumeration enum = v1.elements();
System.out.println("The vector v1 (used method removeElememt()is");
while(enum.hasMoreElements())
System.out.println(enum.nextElement()+"");
System.out.println();
//使用枚举类(Enumeration)的方法取得向量对象的每个元素。
System.out.println("The position of
Object1(top-to-botton):"+v1.indexOf(integer1));
System.out.println("The position of
Object1(tottom-to-top):"+v1.lastIndexOf(integer1));
//按不同的方向查找对象integer1所处的位置
v1.setSize(4);
System.out.println("The new Vector(resized the vector)is:"+v1);
//重新设置v1的大小，多余的元素被抛弃
}
}运行结果：
E:\java01>java VectorApp
The vector v1 is:[one,1,1,two,2,1,1]
The vector v1(used method insetElementAt()) is:
[one,1,three,3.9,1,two,2,1,1]
The vector v1(used method setElementAt()) is:
[one,1,four,3.9,1,two,2,1,1]
The vector v1(useed method removeElement()) is:
one four 3.9 1 two 2 1 1
The position of object1(top-to-botton):3
The position of object1(botton-to-top):7
The new Vector(resized the vector) is:
[one,four,3.9,1]
(1)类vector定义了方法
public final int size();
此方法用于获取向量元素的个数。它们返回值是向量中实际存在的元素个数，而非向量容量。可以调用方法capacity()来获取容量值。
方法：
public final synchronized void setsize(int newsize);
此方法用来定义向量的大小，若向量对象现有成员个数已经超过了newsize的值，则超过部分的多余元素会丢失。
(2)程序中定义Enumeration类的一个对象Enumeration是java.util中的一个接口类，
在Enumeration中封装了有关枚举数据集合的方法。
在Enumeration提供了方法hasMoreElement()来判断集合中是否还有其他元素和方法nextElement()来判断集合中是否还有其他元素和方法nextElement()来获取下一个元素。利用这两个方法，可以依次获得集合中的元素。
Vector中提供方法：
public final synchronized Enumeration elements();
此方法将向量对象对应到一个枚举类型。java.util包中的其他类中也都有这类方法，以便于用户获取对应的枚举类型。
- 评论列表（网友评论仅供网友表达个人看法，并不表明本站同意其观点或证实其描述）
-