List接口——Vector(Stack)

List 接口—— Vector(Stack)

作者： zccst

 

 

1.  接口实现类 Vector

1.1  概述

java.util.Vector 也实现了 List 接口，其描述的也是可变长度的对象数组。

Vector 类以类似数组的方式顺序地存储数据，但是具有比数组更强大的功能；它是允许不同类型元素共存的变长数组。其特点是：

1 ， Vector 类允许不同类型元素共存；

2 ， Vector 对象中元素的个数是可变的，它就像一个动态数组。

Vector 类适合于下列情况使用：

1，  序列中的元素都是对象

2，  需要处理的对象数目不定

3，  需要将不同的类的对象组合成一个数据序列

4，  需要频繁的对序列中的元素进行插入和删除

5，  需要经常定位序列中的对象或进行查找工作

6，  在不同类之间传递大量的数据

 

与 ArrayList 的差别： Vector 是同步（线程安全），但运行效率要低一些，主要用在多线程环境中，而 ArrayList 是不同步的，适合在单线程环境中使用。

 

常用的方法如下：

public Vector();

public Object elementAt(int index);                     // 获取指定位置元素

public void addElement(Object obj);                    // 增加一个元素

public boolean removeElement(Object obj);              // 删除一个元素

public void insertElementAt (int index);               // 向指定位置插入元素

public void removeElementAt(Element obj, int index);   // 删除指定位置元素

public void removeAllElements();                    // 删除所有元素

public Object[] toArray();

 

1.2     Vector 类——构造方法

public Vector();                         // 创建一个空向量

public Vector(int initialCapacity);           // 创建一个指定元素为 initialCapacity 的空向量

public Vector(int Capacity, int increment);  // 创建一个指定元素个数为 Capacity 的空向量，当向量中的元素个数超出容量大小时，以 increment 量增加。

例如： Vector vec = new Vector(10, 5);

 

1.3     Vector 类——常用方法

1 ，向量中增加、插入元素

public void addElement(Object obj);                  // 增加一个元素

public void setElementAt(Element obj, int index);      // 设置指定位置元素

public void insertElementAt (Object obj , int index);     // 向指定位置插入元素

 

 

2 ，获取向量中的元素

public Object elementAt(int index);                  // 获取指定位置元素

public Enumeration elements();                      // 从索引 0 开始列举向量中所有元素。该方法返回一个列举（ Enumeration ）对象。

 

通常用 Enumeration 中的以下两个方法打印向量中的所有元素：

(1)    boolean hasMoreElements();

(2)    public Object nextElement();

用法： for(Enumeration e = vec.elements(); e.hasMoreElements();)

      {  System.out.println(e.nextElement());  }

 

例如： InsertAndPrintElements.java

import java.util.Date;

import java.util.Vector;

import java.util.Enumeration;

public class InsertAndPrintElements{

       public static void main(String[] args){

              Vector vec=new Vector(10,5);

              vec.addElement(new Integer(88));

              vec.addElement(new Character('@'));

              vec.addElement(new Boolean(true));

              vec.addElement(new String("java"));

              System.out.println(" 向量中的所有元素 :");

              myprint(vec);

              vec.insertElementAt(new Date(),2);

              vec.setElementAt(new String(" 向量 "),0);

              System.out.println(" 插入和替换后向量中的所有元素 :");

              myprint(vec);        

       }

       static void myprint(Vector vect){

              for(Enumeration e=vect.elements();e.hasMoreElements();){

                     System.out.print("/t"+e.nextElement());

              }

       }

}

输出结果：

向量中的所有元素 :

    88  @   true   java 插入和替换后向量中的所有元素 :

    向量 @   Sun Dec 27 12:30:45 CST 2009    true   java

 

3 ，删除向量中的元素

public boolean removeElement(Object obj);           // 删除一个元素

public void removeElementAt(Element obj, int index);   // 删除指定位置元素

public void removeAllElements();                    // 删除所有元素

例如： RemoveElements.java

import java.util.Date;

import java.util.Vector;

import java.util.Enumeration;

public class RemoveElements{

       public static void main(String[] args){

              Vector vec=new Vector();

              for(int i=1;i<=3;i++){

                     vec.addElement(new String("java"));

                     vec.addElement(new Integer(i*i));

              }

              System.out.println(" 向量中的所有元素： ");

              myPrint(vec);

              System.out.println(" 删除向量中的所有字符串值为 /"java/" 的元素： ");

              while(vec.removeElement("java"))

                     ;

              myPrint(vec);

              System.out.println(" 删除向量中所有元素后： ");

              vec.removeAllElements();

              myPrint(vec);

       }

       static void myPrint(Vector vect){

              for(Enumeration e=vect.elements(); e.hasMoreElements();)

                     System.out.print("/t"+e.nextElement());

              System.out.println();

       }

}

输出结果：

向量中的所有元素：

    java   1   java   4   java   9

删除向量中的所有字符串值为 "java" 的元素：

    1   4   9

删除向量中所有元素后：

 

4，  查找向量中的元素

public int indexOf(Object elem);                    // 返回查找元素第一次出现的位置

public int lastIndexOf(Object elem);                 // 返回查找元素最后一次出现的位置

public boolean contains(Object elem);                // 如果包含指定元素，返回 true

 

5 ，其他方法

public int Capacity();                             // 容量大小

public int size();                                 // 对象的个数

public void copyInto(Object[] anArray);              // 转换成数组

public Object[] toArray();                         // 转换成数组

public String toString();                           // 以字符串形式输出

 

例如： ToObjectArray.java

import java.util.*;

public class ToObjectArray{

       public static void main(String[] args){

              Vector vec=new Vector(5,10);

              for(int i=1;i<=3;i++){

                     vec.addElement(new String("java"));

                     vec.addElement(new Integer(i*i));

              }

              System.out.println(" 向量中元素的个数： "+vec.size());

              System.out.println(" 向量的容量大小： "+vec.capacity());

              System.out.println(vec.toString());

 

              Object obj1[]=new Object[vec.size()];  // 调用 public void copyInto(Object[] anArray);

              vec.copyInto(obj1);

              show(obj1);

              Object obj2[]=vec.toArray();         // 调用 public Object[] toArray(); 效果相同

              show(obj2);          

       }

       static void show(Object[] obj){

              for(int i=0;i<obj.length;i++)

                     System.out.print(obj[i]+";    ");

              System.out.println();

       }

}

输出结果：

向量中元素的个数： 6

向量的容量大小： 15

[java, 1, java, 4, java, 9]

java; 1; java; 4; java; 9;

java; 1; java; 4; java; 9;

 

1.4     Vector 类与数组的比较

	Vector	Array
内存申请	可动态申请	一次性申请
有序结构	是	是
元素个数	可变	不可变
元素类型	只能是对象，不能是简单数据类型	可以是对象，也可以是简单数据类型
元素类型限制	无	类型必须相同

 

 

 

2 ． Stack 类 ( 继承了 Vector 类 )

java.util.Stack 类继承了 Vector 类，对应数据结构中以“后进先出”方式存储和操作数据的对象栈。

Stack 中常用的栈操作方法如下：

public Stack();

public Object push(Element item);       // 像栈顶放入一个新的对象

public Object pop();                   // 取出栈顶对象，移除它

public Object peek();                  // 查看栈顶对象，但不移除它

public boolean empty();                // 判定是否为空

public void clear();                    // 清除栈中元素

public int search(Object O);             // 查找指定元素位置，并返回位置

 

例如： TestStack.java

import java.util.Date;

import java.util.Stack;

 

public class TestStack{

       public static void main(String[] args) {

              Stack s = new Stack();

              s.push("hello");

              s.push(new Date());

              s.push(400);  // 自动封装 , 等价于 s.push(new Integer(400));

              s.push(3.14);

             

              System.out.println(" 弹栈前 :size=" + s.size());

              System.out.println(s.pop());

              System.out.println(" 弹栈后 :size=" + s.size());

              System.out.println(s.peek());

              System.out.println("peek 操作后 :size=" + s.size());

              while(!s.isEmpty())

                     System.out.println(s.pop());

       }

}

输出结果：

弹栈前 :size=4

3.14

弹栈后 :size=3

400

peek 操作后 :size=3

400

Sun Dec 27 13:24:01 CST 2009

hello