Vector详解

Vector详解

Vector的注意事项

• Vector类的定义说明

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

• Vector底层也是一个对象数组，protected Object[] elementData;

• Vector 是线程同步的，即线程安全，Vector 类的操作方法带有 synchronized 关键字修饰

• 在开发中，需要线程同步安全时，考虑使用Vector

• 当创建 Vector 对象时，如果使用的无参构造器，则 elementData 容量默认为 10 ，当容量不够时，默认 2 倍扩容

• 如果使用的是指定大小的构造器，则初始 elementData 容量为指定大小，当容量不够时，默认 2 倍扩容，也可以指定扩容的增量进行扩容 public Vector(int initialCapacity, int capacityIncrement)

分析使用无参构造器，创建和使用 Vector 的源码

public class Demo04 {
    public static void main(String[] args) {
​
        Vector vector = new Vector();
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
    }
}

---

---

• 1.执行 Vector vector = new Vector();

  • 默认的大小是 10

public Vector() {
    this(10);
}

• 2.执行 this(10); ，调用含有一个参数的构造器

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

• 3.执行 this(initialCapacity, 0); ，调用含有二个参数的构造器

  • this.elementData = new Object[initialCapacity]; ，创建了大小为 10 的elementData 数组

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

• 4.执行 vector.add(E e);

  1. ensureCapacityHelper(elementCount + 1); 先确定是否需要扩容

  2. 然后再执行赋值

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

• 5.执行 ensureCapacityHelper(elementCount + 1);

  • 第一次添加数据时 1-10 < 0 所以此时不需要进行扩容

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

• 6.执行到 vector.add(100); 时

  • minCapacity = 11，elementData.length = 10 ，11-10 > 0 ,所以需要进行扩容

  • 执行 grow(minCapacity);

  • 扩容到原来的两倍

  • 扩容使用的是 Arrays.copyOf()

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);
}

分析使用有参构造器，创建和使用 Vector 的源码

public class Demo04 {
    public static void main(String[] args) {
​
        Vector vector = new Vector(8);
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
    }
}

---

---

• 1.执行 Vector vector = new Vector(8);

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

• 2.执行 this(initialCapacity, 0);

  • this.elementData = new Object[initialCapacity]; ，创建了大小为 8 的elementData 数组

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, int capacityIncrement) 指定扩容的增量

  • 当 capacityIncrement 为 10 时，代表每次扩容增量为10

Vector vector = new Vector(8,10);