JAVA集合8Java中的Vector

Posted 2021-05-21 小拙笔记

【集合】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. 构造方法1：系统会自动对向量进行管理。
2. 构造方法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) + "\\n");
            }
        }