Vector底层源码

最新推荐文章于 2024-06-18 18:58:30 发布

.CONSTANT

最新推荐文章于 2024-06-18 18:58:30 发布

阅读量135

点赞数

分类专栏：集合文章标签： java servlet jvm

本文链接：https://blog.csdn.net/weixin_50518344/article/details/126513595

版权

集合专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文详细介绍了Java集合框架中的Vector类，包括其构造器、属性和主要方法。Vector是一个线程安全的动态数组，它通过synchronized关键字保证并发安全性，并在需要时自动扩容。在扩容策略中，如果设置了容量增长步长，则按步长增加；否则，容量翻倍。此外，还讨论了其在内存管理和线程安全方面的特点。

摘要由CSDN通过智能技术生成

Vector

类定义
@since 1.0 从JDK1.0开始提供的实现类
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

属性:

protected Object[] elementData; 内部的数据存储采用的是Object[]

protected int elementCount; 存储的元素个数

protected int capacityIncrement;容积增长的步长值

构造器

public Vector() {
this(10);
}

public Vector(int initialCapacity) { 参数为初始化容积
this(initialCapacity, 0);
}

public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0) 初始化容积不能小于0
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity]; 初始化数组，不是ArrayList中的延迟初始化
this.capacityIncrement = capacityIncrement;
}

成员方法:

public synchronized boolean add(E e) { 方法上有synchronized，基本上所有的修改方法上都有synchronized关键字，所以线程安全的
modCount++; 修改次数+1
add(e, elementData, elementCount); 参数1为需要添加的元素，参数2为具体存储数据的数组，参数3为元素个数
return true;
}

private void add(E e, Object[] elementData, int s) {
if (s == elementData.length) 如果当前存储的元素个数和数据相等则先进行扩容处理
elementData = grow();
elementData[s] = e;
elementCount = s + 1;
}

private Object[] grow() {
return grow(elementCount + 1);
}

   //具体的扩容处理，调用newCapacity方法获取新容积
   private Object[] grow(int minCapacity) {
return elementData = Arrays.copyOf(elementData,
newCapacity(minCapacity));
}

private int newCapacity(int minCapacity) {
int oldCapacity = elementData.length; 获取原始容积值,也就是存储数据的数组长度
//新容积值的算法：
如果设置了容积增长的步长值，则新容积为原始容积+步长值
如果没有设置容积增长的步长值，则扩容增长100%
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity <= 0) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return minCapacity;
}
return (newCapacity - MAX_ARRAY_SIZE <= 0)
? newCapacity
: hugeCapacity(minCapacity);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;