Java improvement (29) -----Vector

黄舟

Release： 2017-02-11 10:10:25

Original

931 people have browsed it

# — —— ArrayList, Java Improvement (22) — LineDList, explains the principles and implementation processes of ArrayList and LinkedList in detail. It also introduces its implementation class Vector. The Vector class can implement a growable object array.

1. Introduction to Vector

Vector can realize a growable object array. Like an array, it contains components that can be accessed using integer indexes. However, the size of the Vector can be increased or decreased to accommodate addition or deletion operations after the Vector is created.

Vector implements the List interface and inherits the AbstractList class, so we can regard it as a queue and supports related functions such as addition, deletion, modification, traversal, etc.

Vector implements the RandmoAccess interface, which provides random access and fast access. In Vector we can access elements directly.

Vector implements the Cloneable interface, supports the clone() method, and can be cloned.

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

Copy after login

## Vector provides four constructors:

/**
     * 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
     */
     public Vector() {
            this(10);
     }
    
    /**
     * 构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
     */
    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);
    }
    
    /**
     * 使用指定的初始容量和等于零的容量增量构造一个空向量。
     */
    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;
    }

Copy after login

## In terms of member variables, Vector provides elementData, elementCount, capacityIncrement has three member variables. Among them

elementData: "Array of type Object[]", which saves the elements in Vector. According to the design of Vector, elementData is a dynamic array that can dynamically grow as elements increase. The specific increase method is mentioned later (ensureCapacity method). If the container size is not specified when initializing Vector, the default size of 10 is used. .

capacityIncrement: When the size of the vector is greater than its capacity, the capacity is automatically increased by the amount. If the size of capacityIncrement is specified when creating Vector; then, every time the capacity of the dynamic array in Vector increases, the increased size will be capacityIncrement. If the increment of capacity is less than or equal to zero, the capacity of the vector will be doubled each time an increase in capacity is required.

At the same time, Vector is thread-safe!

2. Source code analysis

# remove) will be explained in two ways.

2.1 Add: add(E e)

## The end of the vector.

public synchronized boolean add(E e) {
        modCount++;     
        ensureCapacityHelper(elementCount + 1);    //确认容器大小，如果操作容量则扩容操作
        elementData[elementCount++] = e;   //将e元素添加至末尾
        return true;
    }

Copy after login

## This method is relatively simple, the specific process That is to first confirm the size of the container to see if it needs to be expanded, and then add the E element to the end of this vector.

private void ensureCapacityHelper(int minCapacity) {
        //如果
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    /**
     * 进行扩容操作
     * 如果此向量的当前容量小于minCapacity，则通过将其内部数组替换为一个较大的数组俩增加其容量。
     * 新数据数组的大小姜维原来的大小 + capacityIncrement，
     * 除非 capacityIncrement 的值小于等于零，在后一种情况下，新的容量将为原来容量的两倍，不过，如果此大小仍然小于 minCapacity，则新容量将为 minCapacity。
     */
    private void grow(int minCapacity) {
        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);
    }
    
    /**
     * 判断是否超出最大范围
     * MAX_ARRAY_SIZE：private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
     */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

Copy after login

# For The entire expansion process of Vector is to confirm the expansion size based on capacityIncrement. If capacityIncrement <= 0, it will be doubled, otherwise it will be expanded to capacityIncrement. Of course, the maximum range of this capacity is Integer.MAX_VALUE, that is, 2^32 - 1, so Vector cannot be expanded infinitely.

2.2. remove(Object o)

/**
     * 从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
    }

Copy after login

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

三、Vector遍历

Vector支持4种遍历方式。

3.1、随机访问

因为Vector实现了RandmoAccess接口，可以通过下标来进行随机访问。

for(int i = 0 ; i < vec.size() ; i++){
        value = vec.get(i);
    }

Copy after login

3.2、迭代器

Iterator it = vec.iterator();
    while(it.hasNext()){
        value = it.next();
        //do something
    }

Copy after login

3.2、for循环

for(Integer value:vec){
        //do something
    }

Copy after login

3.4、Enumeration循环

Vector vec = new Vector<>();
    Enumeration enu = vec.elements();
    while (enu.hasMoreElements()) {
        value = (Integer)enu.nextElement();
    }

Copy after login

——————————————————————————————————————————————————————————————————————————

以上就是java提高篇（二九）-----Vector的内容，更多相关内容请关注PHP中文网（www.php.cn）！