B站 韩顺平 老师课程的笔记

Vector

基本介绍

  • Vector 底层也是一个对象数组，protected Object[] elementData;
  • Vector 是线程同步的，即线程安全的，Vector 类的操作方法带有 synchronized关键字，即：
1
2
3
4
5
6
public synchronized E get(int index) {
if(indexx >= elementCount) {
    throw new ArrayIndexOutOfBoundsException(index);
}
return elementDate(index);
}
  • 在开发中，需要线程同步安全时，考虑使用 Vector

与 ArrayList 比较

底层结构 版本 线程安全（同步）效率 扩容倍速
ArrayList 可变数组 jdk1.2 不安全，效率高 如果是有参构造器就扩容 1.5 倍；如果是无参，第一次讲容量设为 10，从第二次开始就扩容 1.5 倍
Vector 可变数组 Object[] jdk1.0 安全，效率不高 如果是无参，默认容量为 10，满后，就按 2 倍扩容；如果指定大小，则每次直接 2 被扩容

看源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public static void main(String[] args) {
    //无参构造器
    //有参数的构造
    Vector vector = new Vector(8);
    for (int i = 0; i < 10; i++) {
        vector.add(100);
    }
    System.out.println("vector=" + vector)
    //1. new Vector() 底层
    /*
        public Vector() {
        this(10);
        }

        补充：如果是 Vector vector = new Vector(8);
        走的方法:
        public Vector(int initialCapacity) {
        this(initialCapacity, 0);
        }

        2. vector.add(i)
        2.1 //下面这个方法就添加数据到 vector 集合
        public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
        }
        2.2 //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
        private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0
        grow(minCapacity);
        }
        2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
        //newCapacity = oldCapacity + ((capacityIncrement > 0) ?
        // capacityIncrement : oldCapacity);
        //就是扩容两倍. 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);
        }
    */
}