概况

容器：管理和储存数据的叫容器
java的容器是在内存层面的（临时存储）

结构

单例集合

List接口

常用方法（多了些索引的方法）

Vector容器类 – 多线程安全的模式

Vector底层是用数组实现的，相关的方法都添加了同步检查，因此“线程安全，效率低”比如，indexOf增加了synchronized同步标记。

package top.baokeaia;

import java.util.List;
import java.util.Vector;

public class VectorTest {

    //    封装循环数组
    static void fo(List list, String msg) {
        System.out.println("------------------------");
        int listLength = list.size();
        //自带方法判断容器是否是空
        if (list.isEmpty()) {
            System.out.println("list.isEmpty()值  =  " + list.isEmpty());
            System.out.println("isEmpty方法判断，容器数组是否为空");
            return;
        }
        if (listLength <= 0) {
            System.out.println("容器数组被清空或者数组出现异常");
            return;
        }
        for (int i = 0; i < listLength; i++) {
            System.out.println(list.get(i) + "-----" + msg);
        }
    }


    public static void main(String[] args) {
        //实例化Vector
        List<String> v = new Vector<>();
        v.add("a");
        v.add("b");
        v.add("c");
        VectorTest.fo(v, "正常循环数组，通过Vecor实现");


    }
}

Vector源码分析

当我们Ctrl点击new 的Vector后
得到Vector的源码
可以看到无参构造

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

    /**
     * Constructs an empty vector with the specified initial capacity and
     * with its capacity increment equal to zero.
     *
     * @param   initialCapacity   the initial capacity of the vector
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    /**
     * Constructs an empty vector so that its internal data array
     * has size {@code 10} and its standard capacity increment is
     * zero.
     */
    public Vector() {
        this(10);
    }

可以看到，当调用无参构造后，执行了有参构造
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;
}
若是传入的initialCapacity 小于0，抛出异常
反之，创建一个size是10的Object数组，
再把计数器capacityIncrement 赋值数组的第一位的下标，也就是0

和ArrayList相比，Vector再new阶段已经创建了一个容量为10的Object数组。

add方法使用ArrayList中一样顺序进入并找到

 public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
 private void ensureCapacityHelper(int minCapacity) {
 //扩容条件
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
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);
    }