Collection:Java集合框架-Vector

2020-10-30

Vector(基于JDK1.8)

Vector

底层是由数组存储的
是java早期 list接口的线程安全的实现类

依赖关系

1
2
3

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

实现了list
实现了RandomAccess 可以快速访问
可以使用Object的clone方法
和ArrayList一样继承了AbstractList

类注释说明

底层是个动态数组存储
Vector底层使用容量和容量增量(capacityIncrement) 来优化存储管理容量大于等于Vector的size Vector的存储以容量增量大小增加可以在插入大量组件前增加 size的容量减少了增量重新分配的数量
since：1.2

属性

// 底层存储的数组
protected Object[] elementData;

// 即 size Vector大小
protected int elementCount;

// 增量 其扩容时 自动增加的数量
// 如果 增量 小于等于0 （没有指定） 则 两倍扩
protected int capacityIncrement;

构造器

// 初始化容量 及其每次扩容大小
public Vector(int initialCapacity, int capacityIncrement) {
     super();
     if (initialCapacity < 0)
         throw new IllegalArgumentException("Illegal Capacity: "+
                                            initialCapacity);
     this.elementData = new Object[initialCapacity];
     this.capacityIncrement = capacityIncrement;
 }

// 初始化容量 但是以后扩容为 两倍扩
public Vector(int initialCapacity) {
     this(initialCapacity, 0);
 }

// 默认初始化容量 10    
public Vector() {
     this(10);
 }

// 通过Collection 创建Vector
public Vector(Collection<? extends E> 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);
 }

扩容方法

// 确保容量安全
private void ensureCapacityHelper(int minCapacity) {
     // overflow-conscious code
     if (minCapacity - elementData.length > 0)
         grow(minCapacity);
 }

// Array的最大值 
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;
 	// 如果目标容量大于 Array的最大值 调用hugeCapacity方法
 	//  即 如果原容量小于Array的最大值 新容量变为 Integer的最大值 
 	//		如果原容量大于Array的最大值 新容量变为 Array的最大值
     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 底层的数组复制和ArrayList一样走的是 System类中的 native的静态方法arraycopy()

方法

// size 方法底层 就是直接返回的  elementCount
public synchronized int size() {
     return elementCount;
 }


// 设置 size（elementCount）大小
public synchronized void setSize(int newSize) {
 	// 版本旗子 
     modCount++;
 	// 如果 设置的容量大于原容量
     if (newSize > elementCount) {
         // 调用 容量安全方法设置容量
         ensureCapacityHelper(newSize);
     } else {
         // 否则 清空 Vector后面的所有的数据 即 超过部分直接置空
         for (int i = newSize ; i < elementCount ; i++) {
             elementData[i] = null;
         }
     }
 	// 最终 使得size变成期望值
     elementCount = newSize;
 }

说明

Vector 修改方法都加上了 synchronized 同步锁或者是直接加入同步代码块所以Vector是线程安全的
如果给Vector设置容量新容量小于原容量则将会抛弃多余的索引并且将其置空
since 1.2以后新加入了一些通过Collection 操作 Vector的方法 (传入的是集合可想而知批量删除批量增加等操作这些操作都会先转成Array 然后再进行操作)