Java-集合(Vector类)

Vector的基本介绍

1)Vactor类的定义;

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

2)Vector底层也是一个对象数组;

protected Object[] elementData;

3)Vector是线程同步的,即线程安全,Vector类的操作方法带有synchronized;

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

4)在开发中,需要线程同步安全时,考虑使用Vector。

Vector与ArrayList的比较

底层结构 版本 线程安全(同步)效率 扩容倍数
ArrayList 可变数组 elementData; jdk 1.2 线程不安全,效率高

无参构造,初始空间10,之后按照1.5倍扩容;

有参构造,初始空间为指定的值,之后按照1.5倍扩容。

Vector 可变数组 elementData; jdk1.0 线程安全,效率不高

无参构造,初始空间为10,之后按照2倍扩容;

一个参数的构造,初始空间为指定的值,之后按照2倍扩容。

两个参数的构造,初始空间为第一个指定的值,扩容增量为第二个指定的值。

Vector源码解读

测试代码

package com.pero.list_;

import java.util.Vector;

/**
 *
 * @author Pero
 * @version 1.0
 */

public class Vector_ {
    public static void main(String[] args) {

        //无参构造
        //Vector vector = new Vector();
        //有参构造
        //Vector vector = new Vector(8);
        Vector vector = new Vector(8,2);

        for (int i = 1; i <= 10; i++) {
            vector.add(i);
        }

        for (int i = 11; i <=20 ; i++) {
            vector.add(i);
        }

    }
}

源码解读

Vector类无参构造器添加元素:

1)执行构造器(调用无参构造器,执行tihis(10)语句,调用一个参数的构造器,创然后调用两个参数的构造器,调用父类构造器,判断初始空间的大小,当小于0时抛出异常,指定可变数组elementData的空间大小,传入指定扩容的大小);

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

2)执行add()方法,添加元素(第一,自动装箱将int类型转换成Integer类型;第二,执行public synchronized boolean add(E e) 方法,modCount++记录集合的修改次数;第三,执行private void ensureCapacityHelper(int minCapacity) 方法,判断集合是否需要扩容,如不需要执行elementData[elementCount++] = e,开始添加元素;如需要扩容,执行private void grow(int minCapacity)方法,首先将elementData数组的长度赋值给oldCapacity,设定一个新的容量newCapacity,判断定义增量的值capacityIncrement是否大于0,如果满足条件,则newCapacity的值为oldCapacity的值+capacityIncrement的值,如果不满足条件,则新容量newCapacity的值是原来容量2倍(oldCapacity+oldCapacity);第四,对新的容量进行判断,首先判断是否小于0,如果满足条件则将初始化minCapacity的值传给newCapacity,如果不满足条件则执行下一条判断,判断newCapacity的值是否大于集合的最大容量MAX_ARRAY_SIZE,如果满足条件,执行private static int hugeCapacity(int minCapacity),首先判断minCapacity是否小于0,如果满足条件则抛出异常,如果不满足条件判断minCapacity是否MAX_ARRAY_SIZE,如果是则返回Integer.MAX_VALUE(2147483647),如果否则返回MAX_ARRAY_SIZE(2147483639),将值赋值给新的容量newCapacity;第五,将原来的elementData数组中的信息拷贝到新的elementData数组中,并进行扩容;第六,将新元素添加到扩容后的集合中);

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
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);
    }
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类一个参数构造器添加元素:

1)执行构造器(调用一个参数的构造器,创然后调用两个参数的构造器,调用父类构造器,判断初始空间的大小,当小于0时抛出异常,指定可变数组elementData的空间大小,传入指定扩容的大小);

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

2)执行add()方法,添加元素(第一,自动装箱将int类型转换成Integer类型;第二,执行public synchronized boolean add(E e) 方法,modCount++记录集合的修改次数;第三,执行private void ensureCapacityHelper(int minCapacity) 方法,判断集合是否需要扩容,如不需要执行elementData[elementCount++] = e,开始添加元素;如需要扩容,执行private void grow(int minCapacity)方法,首先将elementData数组的长度赋值给oldCapacity,设定一个新的容量newCapacity,判断定义增量的值capacityIncrement是否大于0,如果满足条件,则newCapacity的值为oldCapacity的值+capacityIncrement的值,如果不满足条件,则新容量newCapacity的值是原来容量2倍(oldCapacity+oldCapacity);第四,对新的容量进行判断,首先判断是否小于0,如果满足条件则将初始化minCapacity的值传给newCapacity,如果不满足条件则执行下一条判断,判断newCapacity的值是否大于集合的最大容量MAX_ARRAY_SIZE,如果满足条件,执行private static int hugeCapacity(int minCapacity),首先判断minCapacity是否小于0,如果满足条件则抛出异常,如果不满足条件判断minCapacity是否MAX_ARRAY_SIZE,如果是则返回Integer.MAX_VALUE(2147483647),如果否则返回MAX_ARRAY_SIZE(2147483639),将值赋值给新的容量newCapacity;第五,将原来的elementData数组中的信息拷贝到新的elementData数组中,并进行扩容;第六,将新元素添加到扩容后的集合中);

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);
    }
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类一个参数构造器添加元素:

1)执行构造器(调用父类构造器,判断初始空间的大小,当小于0时抛出异常,指定可变数组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;
    }

2)执行add()方法,添加元素(第一,自动装箱将int类型转换成Integer类型;第二,执行public synchronized boolean add(E e) 方法,modCount++记录集合的修改次数;第三,执行private void ensureCapacityHelper(int minCapacity) 方法,判断集合是否需要扩容,如不需要执行elementData[elementCount++] = e,开始添加元素;如需要扩容,执行private void grow(int minCapacity)方法,首先将elementData数组的长度赋值给oldCapacity,设定一个新的容量newCapacity,判断定义增量的值capacityIncrement是否大于0,如果满足条件,则newCapacity的值为oldCapacity的值+capacityIncrement的值,如果不满足条件,则新容量newCapacity的值是原来容量2倍(oldCapacity+oldCapacity);第四,对新的容量进行判断,首先判断是否小于0,如果满足条件则将初始化minCapacity的值传给newCapacity,如果不满足条件则执行下一条判断,判断newCapacity的值是否大于集合的最大容量MAX_ARRAY_SIZE,如果满足条件,执行private static int hugeCapacity(int minCapacity),首先判断minCapacity是否小于0,如果满足条件则抛出异常,如果不满足条件判断minCapacity是否MAX_ARRAY_SIZE,如果是则返回Integer.MAX_VALUE(2147483647),如果否则返回MAX_ARRAY_SIZE(2147483639),将值赋值给新的容量newCapacity;第五,将原来的elementData数组中的信息拷贝到新的elementData数组中,并进行扩容;第六,将新元素添加到扩容后的集合中);

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);
    }
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

你可能感兴趣的:(java,学习,jvm)