java中的Vector类

最新推荐文章于 2023-02-03 17:21:46 发布
Lion小礼
最新推荐文章于 2023-02-03 17:21:46 发布
阅读量1.1k
点赞数 2
分类专栏：移动开发
移动开发专栏收录该内容
21 篇文章
订阅专栏
本文详细介绍了Java中的Vector类，包括其特点、构造函数、常用方法如增删查改等，并通过实例展示了Vector的操作。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
java中的Vector类这两天看书两遇到这个类，索性把这个类整理一下来研究研究。看看API中对Vector的描述。
java.lang.Object
   |
   +----java.util.Vector

 
 
  
  
   
   public class Vector 
   
   
    
    
     
     extends 
     
     Object 
    
    
    
    
     
     implements 
     
     Cloneable, 
     
     Serializable 
    
    
    
    
     
     下列类的父类： 
    
    
    
    
     
     Stack 
    
    
   
   
  
  
 
 
Vector 类实现了可动态扩充的对象数组。类似数组，它包含的元素可通过数组下标来访问。但是，在 Vector 创建之后。Vector 可根据增加和删除元素的需要来扩大或缩小。 
每个向量可通过维护 capacity 和 capacityIncrement 来优化存储空间的管理。capacity 至少和向量大小一样大；但它通常会更大些，因为向量会添加组件，向量的存储空间会根据 capacityIncrement 增加。应用在插入大数量的组件之前会增加向量的容量；这减少了再分配的数量。 

 
 
变量索引 
 
 
  
  
   
   capacityIncrement 
  
  
  
  
   
   当向量的大小超过它的容量时的向量容量的自动增加量。 
  
  
  
  
   
   elementCount 
  
  
  
  
   
   向量中的有效元素数。 
  
  
  
  
   
   elementData 
  
  
  
  
   
   存储向量中元素的数组缓冲区。 
  
  
 
 
 
 
构造子索引 
 
 
  
  
   
   Vector() 
  
  
  
  
   
   构造一个空向量。 
  
  
  
  
   
   Vector(int) 
  
  
  
  
   
   用指定的初始化容量构造一个空向量。 
  
  
  
  
   
   Vector(int, int) 
  
  
  
  
   
   用指定的初始化容量和容量增量构造一个空向量。 
  
  
 
 
 
 
方法索引 
 
 
  
  
   
   addElement(Object) 
  
  
  
  
   
   在向量尾部添加一个指定组件，并把它的长度加一。 
  
  
  
  
   
   capacity() 
  
  
  
  
   
   返回当前向量的容量。 
  
  
  
  
   
   clone() 
  
  
  
  
   
   返回该向量的一个 clone 。 
  
  
  
  
   
   contains(Object) 
  
  
  
  
   
   测试指定对象是否该向量的一个元素。 
  
  
  
  
   
   copyInto(Object[]) 
  
  
  
  
   
   把该向量的元素复制到指定数组中。 
  
  
  
  
   
   elementAt(int) 
  
  
  
  
   
   返回指定下标处的组件。 
  
  
  
  
   
   elements() 
  
  
  
  
   
   返回该向量的元素的一个枚举。 
  
  
  
  
   
   ensureCapacity(int) 
  
  
  
  
   
   增加向量容量，必要的话，保证它至少能容纳由最小容量参数指定的组件数。 
  
  
  
  
   
   firstElement() 
  
  
  
  
   
   返回该向量的第一个元素。 
  
  
  
  
   
   indexOf(Object) 
  
  
  
  
   
   查找给定参数在向量中第一次出现的位置，并用 
   
   equals 方法测试它们是否相等。 
  
  
  
  
   
   indexOf(Object, int) 
  
  
  
  
   
   从 
   
   index 处开始查找给定参数在向量中第一次出现的位置，并用 
   
   equals 方法测试它们是否相等。 
  
  
  
  
   
   insertElementAt(Object, int) 
  
  
  
  
   
   在指定的 
   
   index 处插入作为该向量元素的指定对象。 
  
  
  
  
   
   isEmpty() 
  
  
  
  
   
   测试该向量是否无元素。 
  
  
  
  
   
   lastElement() 
  
  
  
  
   
   返回向量的最后一个元素。 
  
  
  
  
   
   lastIndexOf(Object) 
  
  
  
  
   
   返回向量中最后出现的指定对象的下标。 
  
  
  
  
   
   lastIndexOf(Object, int) 
  
  
  
  
   
   从指定的下标向后查找指定的对象，并返回它的下标。 
  
  
  
  
   
   removeAllElements() 
  
  
  
  
   
   删除向量的所有元素并把它的大小置为零。 
  
  
  
  
   
   removeElement(Object) 
  
  
  
  
   
   从向量中删除第一个出现的参数。 
  
  
  
  
   
   removeElementAt(int) 
  
  
  
  
   
   删除指定下标处的元素。 
  
  
  
  
   
   setElementAt(Object, int) 
  
  
  
  
   
   设置在向量中指定的 
   
   index 处的元素为指定的对象。 
  
  
  
  
   
   setSize(int) 
  
  
  
  
   
   设置向量的大小。 
  
  
  
  
   
   size() 
  
  
  
  
   
   返回该向量的元素数。 
  
  
  
  
   
   toString() 
  
  
  
  
   
   返回该向量的字符串表示。 
  
  
  
  
   
   trimToSize() 
  
  
  
  
   
   把该向量的容量调整为向量的当前大小。 
  
  
 
 

 
 
变量 
elementData  protected Object elementData[]

 
 
  
  
   
   存储向量中的元素的数组缓冲区。向量的容量就是该数组缓冲区的长度。 
   
   
  
  
 
 
elementCount  protected int elementCount

 
 
  
  
   
   向量中的有效元素数。 
   
   
  
  
 
 
capacityIncrement  protected int capacityIncrement

 
 
  
  
   
   当向量大小超过它的容量时的向量容量的自动增加量。如果容量增量为 
   
   0, 向量的容量在每次需要增加时会扩充一倍。 
   
   
  
  
 
 

 
 
构造子
Vector  public Vector(int initialCapacity,
               int capacityIncrement)

 
 
  
  
   
   用指定的初始化容量和容量增量构造一个空向量。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     initialCapacity - 向量的初始容量。 
    
    
    
    
     
     capacityIncrement - 当向量溢出时容量的增长量。 
    
    
   
   
  
  
 
 
Vector  public Vector(int initialCapacity)

 
 
  
  
   
   用指定的初始化容量构造一个空向量。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     initialCapacity - 向量的初始容量。 
    
    
   
   
  
  
 
 
Vector  public Vector()

 
 
  
  
   
   构造一个空向量。 
   
   
  
  
 
 

 
 
方法 
copyInto  public final synchronized void copyInto(Object anArray[])

 
 
  
  
   
   把该向量的元素复制到指定数组中。 数组必须足够大到可容纳向量中的所有对象。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     anArray - 放复制元素的数组。 
    
    
   
   
  
  
 
 
trimToSize  public final synchronized void trimToSize()

 
 
  
  
   
   把该向量的容量调整为向量的当前大小。应用可使用该操作最小化向量存储空间。 
   
   
  
  
 
 
ensureCapacity  public final synchronized void ensureCapacity(int minCapacity)

 
 
  
  
   
   增加向量容量，必要的话，保证它至少能容纳由最小容量参数指定的组件数。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     minCapacity - 要求的最小容量。 
    
    
   
   
  
  
 
 
setSize  public final synchronized void setSize(int newSize)

 
 
  
  
   
   设置向量的大小。 如果新大小大于当前大小，则新的 
   
   null 项添加到向量尾部。如果新的大小小于当前大小，所有下标大于或等于 
   
   newSize 的元素将被抛弃。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     newSize - 向量的新大小。 
    
    
   
   
  
  
 
 
capacity  public final int capacity()

 
 
  
  
   
   返回该向量的当前容量。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     该向量的当前容量。 
    
    
   
   
  
  
 
 
size  public final int size()

 
 
  
  
   
   返回该向量的元素数。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     该向量的元素数。 
    
    
   
   
  
  
 
 
isEmpty  public final boolean isEmpty()

 
 
  
  
   
   测试该向量是否无元素。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     如果该向量无元素，返回 
     
     true ；反之返回 
     
     false 。 
    
    
   
   
  
  
 
 
elements  public final synchronized Enumeration elements()

 
 
  
  
   
   返回该向量的元素的一个枚举。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     该向量的元素的一个枚举。 
    
    
    
    
     
     参见： 
    
    
    
    
     
     Enumeration 
    
    
   
   
  
  
 
 
contains  public final boolean contains(Object elem)

 
 
  
  
   
   测试指定对象是该向量的一个元素。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     elem - 一个对象。 
    
    
    
    
     
     返回值： 
    
    
    
    
     
     如果指定对象是该向量中的一个元素，则返回 
     
     true ；否则返回 
     
     false 。 
    
    
   
   
  
  
 
 
indexOf  public final int indexOf(Object elem)

 
 
  
  
   
   查找给定参数在向量中第一次出现的位置，并用 
   
   equals 方法测试它们是否相等。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     elem - 一个对象。 
    
    
    
    
     
     返回值： 
    
    
    
    
     
     参数在向量中第一次出现处的下标；如果该对象未找到，则返回 
     
     -1 。 
    
    
    
    
     
     参见： 
    
    
    
    
     
     equals 
    
    
   
   
  
  
 
 
indexOf  public final synchronized int indexOf(Object elem,
                                      int index)

 
 
  
  
   
   从 
   
   index 处开始查找给定参数在向量中第一次出现的位置，并用 
   
   equals 方法测试它们是否相等。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     elem - 一个对象。 
    
    
    
    
     
     index - 开始查找的位置的下标。 
    
    
    
    
     
     返回值： 
    
    
    
    
     
     参数在向量中的 
     
     index 处或在它之后第一次出现的位置的下标；如果该对象未找到，则返回 
     
     -1 。 
    
    
    
    
     
     参见： 
    
    
    
    
     
     equals 
    
    
   
   
  
  
 
 
lastIndexOf  public final int lastIndexOf(Object elem)

 
 
  
  
   
   返回向量中最后出现的指定对象的下标。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     elem - 指定的元素。 
    
    
    
    
     
     返回值： 
    
    
    
    
     
     指定对象在向量中最后一次出现处的下标；如果该对象未找到，则返回 
     
     -1 。 
    
    
   
   
  
  
 
 
lastIndexOf  public final synchronized int lastIndexOf(Object elem,
                                      int index)

 
 
  
  
   
   从指定的下标向后查找指定的对象，并返回它的下标。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     elem - 指定的元素。 
    
    
    
    
     
     index - 开始查找的位置的下标。 
    
    
    
    
     
     返回值： 
    
    
    
    
     
     指定对象在向量中的 
     
     index 处或在它之后第一次出现的位置的下标；如果该对象未找到，则返回 
     
     -1 。 
    
    
   
   
  
  
 
 
elementAt  public final synchronized Object elementAt(int index)

 
 
  
  
   
   返回指定下标处的组件。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     index - 向量中的一个下标。 
    
    
    
    
     
     返回值： 
    
    
    
    
     
     指定下标处的元素。 
    
    
    
    
     
     抛出： 
     
     ArrayIndexOutOfBoundsException 
    
    
    
    
     
     如果给出无效的下标。 
    
    
   
   
  
  
 
 
firstElement  public final synchronized Object firstElement()

 
 
  
  
   
   返回该向量的第一个元素。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     该向量的第一个元素。 
    
    
    
    
     
     抛出： 
     
     NoSuchElementException 
    
    
    
    
     
     如果该向量没有元素。 
    
    
   
   
  
  
 
 
lastElement  public final synchronized Object lastElement()

 
 
  
  
   
   返回向量的最后一个元素。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     向量的最后一个元素，即在下标 
     
     size() - 1 处的元素。 
    
    
    
    
     
     抛出： 
     
     NoSuchElementException 
    
    
    
    
     
     如果该向量为空。 
    
    
   
   
  
  
 
 
setElementAt  public final synchronized void setElementAt(Object obj,
                                      int index)

 
 
  
  
   
   设置在向量中指定的 
   
   index 处的元素为指定的对象。 在该位置的先前元素被抛弃。 
   
   下标值必须大于或等于0，并且小于向量的当前大小。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     obj - 元素被设置成的那个对象。 
    
    
    
    
     
     index - 指定下标。 
    
    
    
    
     
     抛出： 
     
     ArrayIndexOutOfBoundsException 
    
    
    
    
     
     如果下标无效。 
    
    
    
    
     
     参见： 
    
    
    
    
     
     size 
    
    
   
   
  
  
 
 
removeElementAt  public final synchronized void removeElementAt(int index)

 
 
  
  
   
   删除指定下标处的元素。 在该向量中下标大于或等于 
   
   index 的元素的下标值减一。 
   
   下标值必须大于或等于0，并且小于向量的当前大小。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     index - 要删除对象的下标。 
    
    
    
    
     
     抛出： 
     
     ArrayIndexOutOfBoundsException 
    
    
    
    
     
     如果下标无效。 
    
    
    
    
     
     参见： 
    
    
    
    
     
     size 
    
    
   
   
  
  
 
 
insertElementAt  public final synchronized void insertElementAt(Object obj,
                                      int index)

 
 
  
  
   
   在指定的 
   
   index 处插入作为该向量元素的指定对象。 在该向量中下标大于或等于 
   
   index 的元素的下标值加一。 
   
   下标值必须大于或等于0，并且小于或等于向量的当前大小。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     obj - 要插入的元素 
    
    
    
    
     
     index - 插入新元素的位置。 
    
    
    
    
     
     抛出： 
     
     ArrayIndexOutOfBoundsException 
    
    
    
    
     
     如果下标无效。 
    
    
    
    
     
     参见： 
    
    
    
    
     
     size 
    
    
   
   
  
  
 
 
addElement  public final synchronized void addElement(Object obj)

 
 
  
  
   
   在向量尾部添加一个指定组件，并把它的长度加一。 当向量大小超过它的容量时向量的容量自动增加。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     obj - 要添加的元素。 
    
    
   
   
  
  
 
 
removeElement  public final synchronized boolean removeElement(Object obj)

 
 
  
  
   
   从向量中删除第一个出现的参数。 如果在向量中找到该对象，在该向量中下标大于或等于 
   
   index 的每个元素的下标值减一。 
   
   
  
  
  
  
   
   
    
    
     
     参数： 
    
    
    
    
     
     obj - 要删除的元素。 
    
    
    
    
     
     返回值： 
    
    
    
    
     
     如果参数是向量的一个元素，返回 
     
     true ；否则返回 
     
     false 。 
    
    
   
   
  
  
 
 
removeAllElements  public final synchronized void removeAllElements()

 
 
  
  
   
   删除向量的所有元素并把它的大小置为零。 
   
   
  
  
 
 
clone  public synchronized Object clone()

 
 
  
  
   
   返回该向量的一个副本 。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     该向量的一个副本。 
    
    
    
    
     
     覆盖： 
    
    
    
    
     
     类 
     
     Object 中的 
     
     clone 
    
    
   
   
  
  
 
 
toString  public final synchronized String toString()

 
 
  
  
   
   返回该向量的字符串表示。 
   
   
  
  
  
  
   
   
    
    
     
     返回值： 
    
    
    
    
     
     该向量的字符串表示。 
    
    
    
    
     
     覆盖： 
    
    
    
    
     
     类 
     
     Object 中的 
     
     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