JAVA-容器二{容器-单例集合-Vector}JAVA从基础开始 --6

概况

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

1.变量 int i
2.数组 int[] i

线性，可快速访问元素
只有length 没有其他方法 不方便使用

结构

单例集合

List接口

有序 ：存入数据与取出顺序是一致的 有对应的索引标记
可重复：List通常满足 e1.equals（e2）

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

◆void add (int index, Object element) – 在指定位括入元崇,以前元全部后移一位–同javascript中的 splice（n,m,Object）
◆Object set (int index,Object elemen – 像改指定位的元素
◆Object get (int index) – 返回指定位而的元东
◆Object remove(int index) – 删除指定位v的元素。后面元素全部移位–同javascript中的 splice（n,1）
◆int indexof (Object o) – 返回第个匹配元素的索引,如果没有该元素,返回-1
◆int lastindexof (Object o) – 返回最后一个匹配元素的索引,如果没有该元素,返回 -1

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

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

Vector的使用方法和ArrayList是相同的，因为他们都实现了List接口。，对List接口中抽象方法做了具体实现

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

可以看到前面加了个synchronized ，线程同步-祥见线程章节，可以使使用这个方法的多线程对象，排队使用这个方法，解决线程安全问题
扩容一次超出容量到20，2次40，以原数组以2倍容量进行扩容

双例集合

结构是 Key – Value

Map接口 :数学中的函数概念 自变量x只能对应一个y

HashMap类