深入理解 Vector

﹏ヽ暗。殇╰゛Y 2023-06-19 07:17 1阅读 0赞

### 文章目录 ###

*  什么是Vector？
 *  Vector与ArrayList有什么区别？
 *   *  相同点
     *  不同点
 *  Vector中的一些成员变量
 *  Vector中的构造方法有哪些？
 *   *  一、Vector(int initialCapacity, int capacityIncrement)
     *  二、Vector(int initialCapacity)
     *  三、Vector()
     *  四、Vector(Collection<? extends E> c)
 *  Vector的扩容
 *   *  grow
     *   *  hugeCapacity()
 *  Vector中常用的操作
 *   *  add()
     *   *  ensureCapacityHelper()
     *  get()
     *  remove()
 *  为什么说Vector是线程安全的？
 *  Vector的简单使用

# 什么是Vector？ #

Vector是一个可以实现自动增长的对象数组（简称动态数组），可以随着向量元素的增加而动态地增长，实际上是一种动态顺序表的应用

# Vector与ArrayList有什么区别？ #

## 相同点 ##

Vector：

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

ArrayList：

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

可以看到 Vector 和 ArrayList 都继承了 AbstractList 类，并且都实现了 List、RandomAccess、Cloneable、Serializable 接口，都可以存储 null 值

## 不同点 ##

这样看来 Vector 和 ArrayLis 的功能是一样的，那为什么会有 Vector 这个动态数组呢？ArrayList不也是动态数组吗？因为 Vector 是基于线程安全的，而ArrayList不是线程安全的，所以有很多人都会说 Vector 是线程安全的 ArrayList

ArrayList默认的扩容倍数是1.5倍（关于ArrayList的扩容可以看下这篇文章 [深入理解ArrayList][ArrayList]），而Vector默认扩容的倍数是2倍

# Vector中的一些成员变量 #

// 底层实现是数组
    protected Object[] elementData;
    
    // 数组元素个数
    protected int elementCount;
    
    // 扩容时增长数量
    protected int capacityIncrement;
    
    // 序列ID
    private static final long serialVersionUID = -2767605614048989439L;

# Vector中的构造方法有哪些？ #

## 一、Vector(int initialCapacity, int capacityIncrement) ##

// 创建输入参数为初始化容量和增长量参数的构造方法
    public Vector(int initialCapacity, int capacityIncrement) { 
        super();
        
        // 如果向量的初始化容量为负数，则抛出 IllegalArgumentException 异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        
        // 将初始化容量的长度作为Object数组（elementData）的实际长度
        this.elementData = new Object[initialCapacity];
        
        // 初始化增量参数
        this.capacityIncrement = capacityIncrement;
    }

## 二、Vector(int initialCapacity) ##

// 创建一个初始化容量且增量为0的数组
    public Vector(int initialCapacity) { 
        this(initialCapacity, 0);
    }

## 三、Vector() ##

// 创建一个初始化容量为10，且增量为0的空数组
    public Vector() { 
        this(10);
    }

## 四、Vector(Collection<? extends E> c) ##

// 创建一个包含指定集合中元素的数组，这些元素会按集合的迭代器返回元素的顺序排列
    public Vector(Collection<? extends E> c) { 
        
        // 将集合元素（c）转换为数组并赋值给Object数组（elementData）
        elementData = c.toArray();
        
        // 获取数组的长度
        elementCount = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            // 将c中的元素拷贝到Object数组（elementData）
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

# Vector的扩容 #

## grow ##

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    // 传入一个最小容量
    private void grow(int minCapacity) { 
        // overflow-conscious code
        
        // oldCapacity翻译过来就是旧的容量，把Object数组（elementData）的长度赋值给旧的容量
        int oldCapacity = elementData.length;
        
        // newCapacity翻译过来就是新的容量，当增量 > 0 
        // 那么新的容量就等于旧的容量+增量，否则为旧的容量的2倍（这里跟ArrayList中的不太一样）
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        
        // 如果新的容量 - 实际需要的容量 < 0
        if (newCapacity - minCapacity < 0)
            // 将实际需要的容量赋值给新的容量
            newCapacity = minCapacity;
        
        // 如果新的容量比数组最大的容量还要大
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 那么就扩容为巨大容量
            newCapacity = hugeCapacity(minCapacity);
        // 用Arrays.copyOf复制
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

### hugeCapacity() ###

巨大容量 hugeCapacity() 方法源码如下（跟ArrayList的一样）：

private static int hugeCapacity(int minCapacity) { 
        
        // 如果传入的实际容量 < 0，则抛出 OutOfMemoryError 异常
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
    }

为了能更好的理解，我们把这段代码搬过来运行测试一下：

/** * 自己新建的类：测试 hugeCapacity 方法的作用 */
    public class HashDemo { 
    
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
        private static int hugeCapacity(int minCapacity) { 
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
                    Integer.MAX_VALUE :
                    MAX_ARRAY_SIZE;
        }
    
        public static void main(String[] args) { 
            // 假设这里传入10
            int i = hugeCapacity(10);
            System.out.println("Integer Max Value is " + Integer.MAX_VALUE);
            System.out.println("hugeCapacity return is " + i);
        }
    }

输出结果为：

可以看到 Integer的最大值为 2147483647，最大值 - 8 = 2147483639，也就是说不管我们传入的数字是多少，经过 hugeCapacity() 运算后得到的结果都是 最大值 - 8 = 2147483639

Integer Max Value is 2147483647
    hugeCapacity return is 2147483639

我们再把传入的数字改大一点，比如我们传入一个比 最大值 - 8 = 2147483639 还要大的数字

public static void main(String[] args) { 
        // 假设这里传入10
        int i = hugeCapacity(2147483640);
        System.out.println("Integer Max Value is " + Integer.MAX_VALUE);
        System.out.println("hugeCapacity return is " + i);
    }

输出结果为：

可以看到当穿传入的数字比 最大值 - 8 = 2147483639 还要大的数字的时候，返回的值就是 Integer 的最大值

Integer Max Value is 2147483647
    hugeCapacity return is 2147483647

这样讲下来应该比较好理解了

# Vector中常用的操作 #

## add() ##

// 采用同步的方式往向量中添加元素
    public synchronized boolean add(E e) { 
        modCount++;
         
        // 因为添加的元素需要动态地扩容，所以调用 ensureCapacityHelper 方法的时候需要 + 1
        ensureCapacityHelper(elementCount + 1);
        // 采用顺序表添加元素，赋值长度+1
        elementData[elementCount++] = e;
        return true;
    }

### ensureCapacityHelper() ###

private void ensureCapacityHelper(int minCapacity) { 
        // overflow-conscious code
        // 如果elementCount + 1 - 数组的容量 > 0 
        if (minCapacity - elementData.length > 0)
            // 则进行扩容操作（上面已讲解grow方法）
            grow(minCapacity);
    }

## get() ##

// 返回向量中指定位置的元素
    public synchronized E get(int index) { 
        // 如果下标 > 数组元素，则抛出 ArrayIndexOutOfBoundsException 异常
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
    
        // 否则返回指定索引的对象
        return elementData(index);
    }

## remove() ##

protected transient int modCount = 0;
    
    public synchronized E remove(int index) { 
        
        // 修改次数+1
        modCount++;
        
        // 如果下标大于元素的数量，则抛出 ArrayIndexOutOfBoundsException 异常
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        
        // 使用下标获取对应的旧值
        E oldValue = elementData(index);
    
        // 计算删除元素后需要移动补位的元素的数量
        int numMoved = elementCount - index - 1;
        
        // 如果这个数量 > 0
        if (numMoved > 0)
            // 拷贝元素
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 删除元素
        elementData[--elementCount] = null; // Let gc do its work
    
        // 返回旧值
        return oldValue;
    }

# 为什么说Vector是线程安全的？ #

可以看到Vector的操作都是使用synchronized关键字进行同步的，也就是说是线程安全的，由于Vector是同步的，所以效率要比ArrayList低

# Vector的简单使用 #

创建一个Vector向量，添加元素

输出结果为：

> \[ArrayList, HashMap, ConcurrentHashMap, LinkedList, LinkedHashMap\]

使用迭代器输出结果

public class HashDemo { 
        public static void main(String[] args) { 
            Vector<String> vector = new Vector<>();
            vector.add("ArrayList");
            vector.add("HashMap");
            vector.add("ConcurrentHashMap");
            vector.add("LinkedList");
            vector.add("LinkedHashMap");
    
            Iterator<String> iterator = vector.iterator();
            while (iterator.hasNext()){ 
                System.out.println(iterator.next()); // 这里一定要加上next()，不然会出现死循环
            }
        }
    }

输出结果为：

> ArrayList  
> HashMap  
> ConcurrentHashMap  
> LinkedList  
> LinkedHashMap

[ArrayList]: https://blog.csdn.net/Woo_home/article/details/103177912