Vector 学习笔记

下一篇：Stack学习笔记 

 

OverView

 

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。 并且Vector类是同步的。

 

Stack 类表示后进先出（LIFO）的对象堆栈。Stack类继承自Vector。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

 

 

 

 

 

Java Collections framework继承关系如图：

 

 

 

一、Vector

 

Vector对象可以存储任何对象。

 

Creating Vectors-创建Vector对象

 

Vector有四个构造函数，如下：

 

1.1、public Vector()

 

构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。如果容量不够用，默认为双倍扩容。例如：

 

 

Demo1：

Vector v = new Vector();//默认容量为10

for(int i=0;i<12;i++){//i最后大于10，将会自动扩容

       v.add(i);

}

System.out.println(“扩容后容量为：”+v.capacity());

 

结果为：扩容后容量为：20

 

 

Demo2

Vector v = new Vector();//默认容量为10

for(int i=0;i<22;i++){//i最后大于10，将会自动扩容

       v.add(i);

}

System.out.println(“扩容后容量为：”+v.capacity());

结果为：扩容后容量为：40

扩容步骤为：i=10时，vector对象容量不够，扩容为20；当i=20时，vector再次双倍扩容，变为40

 

1.2、public Vector(int initialCapacity)

 

构造一个向量，设置其内部数据数组的大小为initialCapacity

 

1.3、public Vector(int initialCapacity, int capacityIncrement)

 

使用指定的初始容量和容量增量构造一个空的向量

 

Demo1：

Vector v = new Vector(10,5);//默认容量为10，扩容增量为5

for(int i=0;i<12;i++){//当i=10时，容量不够，容量加5

       v.add(i);

}

System.out.println(“扩容后容量为：”+v.capacity());

结果为：扩容后容量为：15

 

1.4、public Vector(Collection<? extends E> c)

构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列

 

Demo1：

 

String[] arr={"avatar","lady gaga","kaka"};

Vector v = new Vector(Arrays.asList(arr));

System.out.println(v.toString());//输出[avatar, lady gaga, kaka]

 

1.5、Note：如果初始容量被设置为负数，则会抛出IllegalArgumentException异常。

 

Adding Elements-添加元素

 

2.1、Adding at the End

 

Vector类提供了一下集中方法添加元素：

public boolean add(Object element) //将指定元素添加到此向量的末尾。

public void addElement(Object element) //将指定的组件添加到此向量的末尾，将其大小增加 1

上面这这两种添加元素方法本质上是一样的，都是把元素添加到Vector对象的末尾，不同之处为add()方法总是返回true,而addElement()方法没有返回值。

 

Tip：Vector对象允许添加null和重复值

 

Demo1：

Vector v = new Vector();

v.add(null);

v.add("avatar");

v.add("avatar");

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

输出结果：[null, avatar, avatar]

 

2.2、Adding in the Middle-添加到Vector中指定位置

 

public void add(int index, Object element)// 将指定元素添加到此向量的末尾

public void insertElementAt(Object element, int index)// 将指定对象作为此向量中的组件插入到指定的 index 处

       以上这两种方法可以将元素插入到Vector的中间，其中index重0开始，但是这些操作比较费性能，如果你经常需要这样操作，也许Vector并不是最适合你的结构，你可以使用LinkedList代替Vector。

       下图直观表达出元素插入到Vector对象中时的数组移动方式，后两个元素的index将会加1

 

 

 

 

 

 

 

 

 

2.8、Removing a Range of Elements-删除指定范围元素

 

protected void removeRange(int fromIndex, int toIndex) 从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。

 

2.9、Replacing Elements-替换元素

 

public Object set(int index, Object element) 用指定的元素替换此向量中指定位置处的元素。

public void setElementAt(Object obj, int index) 将此向量指定 index 处的组件设置为指定的对象。

 

Demo1：

Vector v = new Vector();

for(int i=0;i<12;i++){

       v.add(i);

}

Integer del=(Integer)v.set(1, 123);

System.out.println("替换对象为："+del);

System.out.println("所有对象："+v);

输出结果为：

替换对象为：1

所有对象：[0, 123, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

 

2.10、Storage Size-存储元素数量

 

public int size()返回此向量中的元素数。

public void setSize(int newSize) 设置此向量的大小。

如果你设置的大小小于现在Vector元素的数量，Vector会从新的长度处开始截断。如果增加大小，则会在现有对象末尾添加null元素。setSize（0）将会删除所有元素，如果这样，你调用isEmpty（）方法将会返回true。

public boolean isEmpty()测试此向量是否不包含元素。

 

Demo1：

Vector v = new Vector();

for(int i=0;i<12;i++){

       v.add(i);

}

System.out.println("设置前所有对象："+v);

v.setSize(5);

System.out.println("设置后所有对象："+v);

输出结果：

设置前所有对象：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

设置后所有对象：[0, 1, 2, 3, 4]

 

Demo2：

Vector v = new Vector();

for(int i=0;i<12;i++){

       v.add(i);

}

System.out.println("设置前所有对象："+v);

v.setSize(15);

System.out.println("设置后所有对象："+v);

输出结果：

设置前所有对象：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

设置后所有对象：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, null, null, null]

 

Demo3：

Vector v = new Vector();

for(int i=0;i<12;i++){

       v.add(i);

}

System.out.println("设置前所有对象："+v);

v.setSize(0);

System.out.println("设置后所有对象："+v);

输出结果：

设置前所有对象：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

设置后所有对象：[]

 

 

2.11、Storage Capacity-存储容量

 

Vector容量：在Vector没有重新调整任何内部数据结构的大小之前，能够装入Vector的元素的数量。最好减少调整内部数据结构大小的次数。如果容量设置过大，内存将会浪费。获取当前Vector容量，可以调用capacity()方法。

       每添加一个元素，最好条用方法tirmSize().这个方法会删除多余的容量。

public void trimToSize()对此向量的容量进行微调，使其等于向量的当前大小

 

Demo1：

Vector v = new Vector();

for(int i=0;i<12;i++){

       v.add(i);

}

System.out.println("设置前容量："+v.capacity());

v.trimToSize();

System.out.println("设置后容量："+v.capacity());

输出结果：

设置前容量：20

设置后容量：12

 

2.12、Vector Immutability-固定vector

 

如果vector内容不再改变，你可能希望vector只读，这将使vector得元素不会被修改。collections类提供了方法unmodifyableList,既然Vector是List子类，我们就可以调用此方法获取一个只读集合。如果vector变为只读，则访问vector就不需要同步了。

Vector v = new Vector();

// fill vector

List l = Collections.unmodifiableList(v);

 

2.13、Getting by Index-通过索引获取元素

public Object get(int index) 返回向量中指定位置的元素。

public Object elementAt(int index) 返回指定索引处的组件。

 

Demo1：

Vector v = new Vector();

v.add("Hello");

String s = (String)v.get(0);

System.out.println(s);

输出结果：Hello

 

2.14、Getting by Position-获取指定位置元素

 

public Object firstElement()返回此向量的第一个组件（位于索引 0) 处的项）。

public Object lastElement()返回此向量的最后一个组件。

 

2.15、Enumerating through the Elements-枚举元素

 

Vector v = . . .

Enumeration e = v.elements();

while (e.hasMoreElements()) {

  process(e.nextElement());

}

 

2.16、Inherited Methods from AbstractList-继承自AbstractList类的方法

 

public Iterator iterator()

public ListIterator listIterator()

public ListIterator listIterator(int index)

 

Demo1：

Vector v = . . .

Iterator i = v.iterator();

while (i.hasNext()) {

  process(e.next());

}

 

2.17、Checking for Existence-检查元素是否存在

 

public boolean contains(Object element) 如果此向量包含指定的元素，则返回 true

 

 

2.18、Checking for Position-检查元素位置

 

public int indexOf(Object element) 返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。

public int indexOf(Object element, int index)  返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。

 

2.19、Checking for Position from End-从末尾检查位置

 

public int lastIndexOf(Object element) 返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。

public int lastIndexOf(Object element, int index)  返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。

 

2.20、Checking for Collection Containment-检查一个结合是否存在

 

public boolean containsAll(Collection c)  如果此向量包含指定 Collection 中的所有元素，则返回 true。

 

2.21、Cloning Vectors-克隆

 

public Object clone()返回向量的一个副本。

 

Demo1：

Vector v1 = new Vector();

v1.add("gaga");

v1.add("avatar");

 

Vector v2 = (Vector)v1.clone();

Collections.sort(v2);

 

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

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

输出结果：

[gaga, avatar]

[avatar, gaga]

 

2.22、Copying Vectors-拷贝

 

public Object[] toArray()返回一个数组，包含此向量中以恰当顺序存放的所有元素。

public Object[] toArray(Object[] a) 返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。

public void copyInto(Object[] anArray) 将此向量的组件复制到指定的数组中。

 

2.23、Working with Subsets –获取子集

 

public List subList(int fromIndex, int toIndex) 返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。

 

subList方法不是克隆vector对象，而是源vector对象和新的子集引用指向同一个内部数据结构。这就意味着两者的改动都会直接互相改动。请看下图：

 

 

 

 

 

 

 

 

 

 

2.24、Checking Vectors for Equality-检查是否相等

 

public boolean equals(Object o) 比较指定对象与此向量的相等性。

如果两个vector对象元素数量相等并且所有对应位置的元素都相等，则这两个vector对象相等。

 

2.25、Serializing Vector-序列化

 

Vector类实现了类Serializable接口，但这并不意味着所有的Vector对象能够自动序列化。如果Vector对象内部的元素都是可序列化得，那么Vector对象也就可以被序列化；如果Vector对象中有一个元素不能被序列化，则会抛出NotSerializableException错误。

 

Demo1：

import java.io.*;

import java.util.*;

public class SaveVector {

  public static void main (String args[]) throws Exception {

    Vector v = new Vector(Arrays.asList(args));

    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    ObjectOutputStream oos = new ObjectOutputStream(baos);

    oos.writeObject(v);

    oos.close();

    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

    ObjectInputStream ois = new ObjectInputStream(bais);

    Vector v2 = (Vector)ois.readObject();

    Enumeration e = v.elements();

    while (e.hasMoreElements()) {

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

    }

  }

}