一、Vector简介

Vector可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。不过，Vector的大小是可以增加或者减小的，以便适应创建Vector后进行添加或者删除操作。
Vector实现List接口，继承AbstractList类，所以我们可以将其看做队列，支持相关的添加、删除、修改、遍历等功能。
Vector实现RandmoAccess接口，即提供了随机访问功能，提供提供快速访问功能。在Vector我们可以直接访问元素。
Vector 实现了Cloneable接口，支持clone()方法，可以被克隆。

类定义

    public class Vector<E>
        extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

主要构造函数

    //构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。 
    public Vector() {
            this(10);
    }

    //使用指定的初始容量和等于零的容量增量构造一个空向量。 
     public Vector(int initialCapacity) {
            this(initialCapacity, 0);
     }

    //使用指定的初始容量和容量增量构造一个空的向量。
     public Vector(int initialCapacity, int capacityIncrement) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
            this.capacityIncrement = capacityIncrement;
        }

在成员变量方面，Vector提供了elementData , elementCount， capacityIncrement三个成员变量。其中

elementData：Object[]类型的数组，它保存了Vector中的元素。按照Vector的设计elementData为一个动态数组，可以随着元素的增加而动态的增长，其具体的增加方式后面提到（ensureCapacity方法）。如果在初始化Vector时没有指定容器大小，则使用默认大小为10.
elementCount：Vector 对象中的有效组件数。
capacityIncrement：向量的大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时，增加的大小都是capacityIncrement。如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。

二、源码

add()

      //add(E e)：将指定元素添加到此向量的末尾。
      public synchronized boolean add(E e) {  
               modCount++; 
               //确认容器大小，如果超过容量则扩容      
               ensureCapacityHelper(elementCount + 1);    
               //将e元素添加至末尾  
               elementData[elementCount++] = e;     
               return true;  
     }

这个方法相对而言比较简单，具体过程就是先确认容器的大小，看是否需要进行扩容操作，然后将E元素添加到此向量的末尾。

    private void ensureCapacityHelper(int minCapacity) {
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
     }

进行扩容操作，如果此向量的当前容量小于minCapacity，则通过将其内部数组替换为一个较大的数组俩增加其容量。新数据数组的大小将维持原来的大小 + capacityIncrement，除非 capacityIncrement 的值小于等于零，在后一种情况下，新的容量将为原来容量的两倍，不过，如果此大小仍然小于 minCapacity，则新容量将为 minCapacity。

    private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
    
       //新容器大小 
       //若容量增量系数(capacityIncrement) > 0，
       //则将容器大小增加到capacityIncrement ,否则将容量增加一倍 
    
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                             capacityIncrement : oldCapacity);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

    //判断是否超出最大范围 
     private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
        }

对于Vector整个的扩容过程，就是根据capacityIncrement确认扩容大小的，若capacityIncrement <= 0 则扩大一倍，否则扩大至capacityIncrement 。当然这个容量的最大范围为Integer.MAX_VALUE即，2^32 - 1，所以Vector并不是可以无限扩充的。

remove()

    /** 
         * 从Vector容器中移除指定元素E 
         */  
        public boolean remove(Object o) {  
            return removeElement(o);  
        }  
    
        public synchronized boolean removeElement(Object obj) {  
            modCount++;  
            int i = indexOf(obj);   //计算obj在Vector容器中位置  
            if (i >= 0) {  
                removeElementAt(i);   //移除  
                return true;  
            }  
            return false;  
        }  
    
        public synchronized void removeElementAt(int index) {  
            modCount++;     //修改次数+1  
            if (index >= elementCount) {   //删除位置大于容器有效大小  
                throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);  
            }  
            else if (index < 0) {    //位置小于 < 0  
                throw new ArrayIndexOutOfBoundsException(index);  
            }  
            int j = elementCount - index - 1;  
            if (j > 0) {     
                //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。  
                //也就是数组元素从j位置往前移  
                System.arraycopy(elementData, index + 1, elementData, index, j);  
            }  
            elementCount--;   //容器中有效组件个数 - 1  
            elementData[elementCount] = null;    //将向量的末尾位置设置为null  
        }

因为Vector底层是使用数组实现的，所以它的操作都是对数组进行操作，只不过其是可以随着元素的增加而动态的改变容量大小，其实现方法是是使用Arrays.copyOf方法将旧数据拷贝到一个新的大容量数组中。

Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。

它的内容包括：

大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：

想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询

同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】即可免费领取。

阅读全文

Java 集合