【集合】Java中的Vector
参考：
https://www.cnblogs.com/zheting/p/7708366.html
https://blog.csdn.net/w15971597/article/details/48937701
https://www.cnblogs.com/xiaostudy/p/9526270.html
一、Vector的用途
Vector是java.util.vector提供的向量类，以实现类似动态数组的功能。
Vector可拥有时下自动增长的对象数组。
创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型、也不需预先选定向量的容量，并可以方便地进行查找。
对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况，可以考虑使用向量类。
Vector类中主要成员字段如下：
- elementData：是一个Object类型的数组索引，在构造方法中会通过new方式、或toArray()方式创建存储空间。在向Vertor中添加对象过程中，如果存储空间满，会自动扩充空间。
- elementCount：记录当前Vector中实际保存的对象个数。size()方法返回的就是本字段值。
- capacityIncrement：当Vector中存储空间占用完毕后，通过本参数指定每次扩充的扩充量。当capacityincrement为0的时候，则每次扩充一倍。
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
}
二、Vector的构造方法
Vector提供了三种构造方法：
public vector()
public vector(int initialcapacity,int capacityIncrement)
public vector(int initialcapacity)
- 构造方法1：系统会自动对向量进行管理。
- 构造方法2、构造方法3：则系统将根据参数设置关联向量：
- initialcapacity设定向量对象的容量（即向量对象可存储数据的大小），当真正存放的数据个数超过容量时。系统会扩充向量对象存储容量。
- capacityincrement给定了每次扩充的扩充值。当capacityincrement为0的时候，则每次扩充一倍，利用这个功能可以优化存储。
三、Vector的插入方法
1. 向Vector的尾部插入对象
public synchronized boolean add(E e)
public synchronized void addElement(E obj)
将obj插入向量的尾部。obj可以是任何类型的对象。对同一个向量对象，亦可以在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数组转换成相应的对象。
样例：向Vector中插入Integer对象
Vector v1 = new Vector();
Integer integer1 = new Integer(1);
v1.addElement(integer1);
2. 替换Vector中指定索引的对象
public synchronized void setElementAt(E obj, int index)
将index处的对象设置成obj，原来的对象将被覆盖。
3. 在Vector指定位置插入对象
public synchronized void insertElementAt(E obj, int index)
在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。
4.把一个集合整体添加到Vector中
public synchronized boolean addAll(Collection<? extends E> c)
样例：
Vector vector1 = new Vector();
Vector vector2 = new Vector();
vector1.addElement("demo1");
vector1.addElement("demo2");
vector1.addElement("demo3");
vector1.addElement("demo4");
vector2.addAll(vector1);
四、查询Vector中对象个数
public final int size();
此方法用于获取向量元素的个数。它们返回值是向量中实际存在的元素个数，而非向量容量。可以调用方法capacity()来获取容量值。
五、在Vector中搜索对象
1. 获取Vector中第一个对象
public synchornized E firstElement()
获取向量中的首个obj 。
2. 获取Vector中最后一个对象
public synchornized E lastElement()
获取向量中的最后一个obj 。
3. 指定索引，获取对象
public synchronized E elementAt(int index)
获取向量中指定位置的obj 。
4. 从头搜索指定对象，返回对象所在位置索引
public int indexOf(E obj)
从向量头开始搜索obj，返回所遇到的第一个obj对应的下标。若不存在此obj，返回-1。
5. 从指定索引位置开始正向搜索指定对象，返回对象所在位置索引
public synchronized int indexOf(E obj, int index)
从index所表示的下标处开始搜索obj，返回所遇到的第一个obj对应的下标。若不存在此obj，返回-1。
6. 从尾搜索指定对象，返回对象所在位置索引
public int lastindexOf(E obj)
从向量尾开始搜索obj，返回所遇到的第一个obj对应的下标。若不存在此obj，返回-1。
7. 从指定索引位置开始逆向搜索指定对象，返回对象所在位置索引
public synchornized int lastIndexOf(E obj, int index)
从index所表示的下标处由尾至头逆向搜索obj，返回所遇到的第一个obj对应的下标。若不存在此obj，返回-1。
七、从Vector中删除对象
1. 删除Vector所有对象
public synchronized void removeAllElement();
删除向量所有的对象。
2. 指定索引删除对象
public synchronized void removeElementAt(int index)
删除index所指的地方的对象。
3. 指定索引范围，删除对象
protected synchronized void removeRange(int fromIndex, int toIndex)
3. 指定对象，从首次出现的位置删除
public synchronized void removeElement(E obj)
从向量中删除obj对象。若有多个存在，则从向量头开始，删除找到的第一个与obj相同的向量成员。
八、遍历Vector中对象
Vector的elements()方法创建一个匿名类对象，此类包含hasMoreElements()和nextElement()方法，如下：
public Enumeration<E> elements() {
return new Enumeration<E>() {
int count = 0;
public boolean hasMoreElements() {
return count < elementCount;
}
public E nextElement() {
synchronized (Vector.this) {
if (count < elementCount) {
return elementData(count++);
}
}
throw new NoSuchElementException("Vector Enumeration");
}
};
}
Enumeration定义：
public interface Enumeration<E> {
boolean hasMoreElements();
E nextElement();
}
使用样例：
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class TestVector {
public void test01() {
Vector<String> hs = new Vector<String>();
hs.add("aa");
hs.add("bb");
hs.add("aa");
hs.add("cc");
hs.add("aa");
hs.add("dd");
printSet2(hs);
}
public void printSet2(Vector<String> hs) {
Enumeration<String> elements = hs.elements();
while (elements.hasMoreElements()) {
System.out.println(elements.nextElement());
}
}
public static void main(String[] args) {
new TestVector().test01();
}
}
九、其他方法
1. 设置Vector新Size，超过部分丢弃
public synchronized void setSize(int newsize);
此方法用来定义向量的大小，若向量对象现有成员个数已经超过了newsize的值，则超过部分的多余元素丢弃。
2. Vector判空
public synchronized boolean isEmpty()
3. 把向量元素复制到数组中
public synchronized void copyInto(Object[] anArray) {
System.arraycopy(elementData, 0, anArray, 0, elementCount);
}
十、使用Vector创建二维数组
定义样例：
List intList1 = Arrays.asList(1,4,7,11,15);
List intList2 = Arrays.asList(2,5,8,12,19);
List intList3 = Arrays.asList(3,6,9,16,22);
List intList4 = Arrays.asList(10,13,14,17,24);
List intList5 = Arrays.asList(18,21,23,26,30);
Vector<Integer> v1 = new Vector();
v1.addAll(intList1);
Vector<Integer> v2 = new Vector();
v2.addAll(intList2);
Vector<Integer> v3 = new Vector();
v3.addAll(intList3);
Vector<Integer> v4 = new Vector();
v4.addAll(intList4);
Vector<Integer> v5 = new Vector();
v5.addAll(intList5);
//创建Vector，每个单元保存的是Vector对象
Vector<Vector<Integer> > matrix = new Vector();
matrix.addElement(v1);
matrix.addElement(v2);
matrix.addElement(v3);
matrix.addElement(v4);
matrix.addElement(v5);
for(int i = 0; i < matrix.size(); i++) { //matrix.size()是3
for(int j = 0; j < matrix.elementAt(i).size(); j++) { //每个二维Vector的size()是5
System.out.print(matrix.elementAt(i).elementAt(j) + "
");
}
}