本文共 8128 字，大约阅读时间需要 27 分钟。

1：Vector简介

Java中Vector类是允许不同类型元素共存的变长数组，Java.util.Vector提供了向量（Vector）类以实现类似动态数组的功能。在Java语言中是没有指针概念的，但如果能正确灵活地使用指针又确实可以大大提高程序的质量，比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷，Java提供了丰富的类库来方便编程者使用，Vector类便是其中之一。事实上，灵活使用数组也可完成向量类的功能，向量类中提供的大量方法也大大方便了用户的使用。

2：属性和构造方法

/**     * The array buffer into which the components of the vector are     * stored. The capacity of the vector is the length of this array buffer,     * and is at least large enough to contain all the vector's elements.     *     * 
Any array elements following the last element in the Vector are null.     *     * @serial     * 存放元素的数组     */    protected Object[] elementData;   /**     * The number of valid components in this {@code Vector} object.     * Components {@code elementData[0]} through     * {@code elementData[elementCount-1]} are the actual items.     *     * @serial     * 数组中实际元素数量     */    protected int elementCount;   /**     * The amount by which the capacity of the vector is automatically     * incremented when its size becomes greater than its capacity.  If     * the capacity increment is less than or equal to zero, the capacity     * of the vector is doubled each time it needs to grow.     *     * @serial     * 每次扩容的大小，如果为 0，每次扩容为原来的两倍     */    protected int capacityIncrement;   /**     * Constructs an empty vector with the specified initial capacity and     * capacity increment.     *     * @param   initialCapacity     the initial capacity of the vector     * @param   capacityIncrement   the amount by which the capacity is     *                              increased when the vector overflows     * @throws IllegalArgumentException if the specified initial capacity     *         is negative     * 初始化容器，并指定初始容量和扩容大小     */    public Vector(int initialCapacity, int capacityIncrement) {
           super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity);        this.elementData = new Object[initialCapacity];        this.capacityIncrement = capacityIncrement;    }   /**     * Constructs an empty vector with the specified initial capacity and     * with its capacity increment equal to zero.     *     * @param   initialCapacity   the initial capacity of the vector     * @throws IllegalArgumentException if the specified initial capacity     *         is negative     * 初始化容器并指定初始容量，扩容大小默认为0(即每次扩容为原来的两倍)     */    public Vector(int initialCapacity) {
           this(initialCapacity, 0);    }   /**     * Constructs an empty vector so that its internal data array     * has size {@code 10} and its standard capacity increment is     * zero.     * 初始化容器并指定初始容量10，扩容大小默认为0(即每次扩容为原来的两倍)     */    public Vector() {
           this(10);    }       /**     * Constructs a vector containing the elements of the specified     * collection, in the order they are returned by the collection's     * iterator.     *     * @param c the collection whose elements are to be placed into this     *       vector     * @throws NullPointerException if the specified collection is null     * @since   1.2     * 以一个集合为默认元素，初始化容器     */    public Vector(Collection
     c) {
           elementData = c.toArray();        elementCount = elementData.length;        // c.toArray might (incorrectly) not return Object[] (see 6260652)        if (elementData.getClass() != Object[].class)            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);    }

3：增删查改

增加和删除操作才算作结构的改变，才会记录修改次数。修改时不记录修改次数。

/**     * Appends the specified element to the end of this Vector.     *     * @param e element to be appended to this Vector     * @return {@code true} (as specified by {@link Collection#add})     * @since 1.2     * 插入元素到数组的末尾     */    public synchronized boolean add(E e) {
           modCount++;        ensureCapacityHelper(elementCount + 1);        elementData[elementCount++] = e;        return true;    }       /**     * Adds the specified component to the end of this vector,     * increasing its size by one. The capacity of this vector is     * increased if its size becomes greater than its capacity.     *     * 
This method is identical in functionality to the     * {@link #add(Object) add(E)}     * method (which is part of the {@link List} interface).     *     * @param   obj   the component to be added     * 与add(E e)方法相同，但是没有返回值     */    public synchronized void addElement(E obj) {
           modCount++;        ensureCapacityHelper(elementCount + 1);        elementData[elementCount++] = obj;    }   /**     * This implements the unsynchronized semantics of ensureCapacity.     * Synchronized methods in this class can internally call this     * method for ensuring capacity without incurring the cost of an     * extra synchronization.     *     * @see #ensureCapacity(int)     * 超出容量即进行扩增     */    private void ensureCapacityHelper(int minCapacity) {
           // overflow-conscious code        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }       /**     * The maximum size of array to allocate.     * Some VMs reserve some header words in an array.     * Attempts to allocate larger arrays may result in     * OutOfMemoryError: Requested array size exceeds VM limit     * 允许数组最大容量值     */    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;    // 容量扩增处理     private void grow(int minCapacity) {
           // overflow-conscious code        int oldCapacity = elementData.length;        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);    }   /**     * Inserts the specified element at the specified position in this Vector.     * Shifts the element currently at that position (if any) and any     * subsequent elements to the right (adds one to their indices).     *     * @param index index at which the specified element is to be inserted     * @param element element to be inserted     * @throws ArrayIndexOutOfBoundsException if the index is out of range     *         ({@code index < 0 || index > size()})     * @since 1.2     * 在某个位置插入元素     */    public void add(int index, E element) {
           insertElementAt(element, index);    }   /**     * Inserts the specified object as a component in this vector at the     * specified {@code index}. Each component in this vector with     * an index greater or equal to the specified {@code index} is     * shifted upward to have an index one greater than the value it had     * previously.     *     * 
The index must be a value greater than or equal to {@code 0}     * and less than or equal to the current size of the vector. (If the     * index is equal to the current size of the vector, the new element     * is appended to the Vector.)     *     * 
This method is identical in functionality to the     * {@link #add(int, Object) add(int, E)}     * method (which is part of the {@link List} interface).  Note that the     * {@code add} method reverses the order of the parameters, to more closely     * match array usage.     *     * @param      obj     the component to insert     * @param      index   where to insert the new component     * @throws ArrayIndexOutOfBoundsException if the index is out of range     *         ({@code index < 0 || index > size()})     * 在某个位置插入元素     */    public synchronized void insertElementAt(E obj, int index) {
           modCount++;        if (index > elementCount) {
               throw new ArrayIndexOutOfBoundsException(index                                                     + " > " + elementCount);        }        ensureCapacityHelper(elementCount + 1);        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);        elementData[index] = obj;        elementCount++;    }

转载地址：https://javalib.blog.csdn.net/article/details/105983916 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！