java源码分析---Vector类（JDK14）

更多源码分析，请点击

Vector

Vector 和 ArrayList 原理实现差不多，但是 Vector 是 线程安全 的，在效率上没有 ArrayList 高，因为为保证线程安全，使用 synchronized 关键字修饰方法。

Vector 底层采用 Object 数组来保存数据，所以如果要保存基本类型需要使用他们的包装类。

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
}

elementData 用于保存列表中元素的 Object 数组。

elementCount 用来保存当前列表中元素的数量。

capacityIncrement 如果该值大于零时，数组扩容时增加的容量为该值。 如果该值小于或等于零，则数组扩容时扩容为当前数组长度的二倍。

Vector(int, int)

构造函数 ，创建一个 Vector 对象，初始化容量为 initialCapacity ，初始化容量增量为 capacityIncrement 。

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

Vector(initialCapacity)

构造函数 ，创建一个 Vector 对象，初始化容量为 initialCapacity ，初始化容量增量为 0 。

public Vector(int initialCapacity) {
this(initialCapacity, 0);
}

Vector()

构造函数 ，创建一个 Vector 对象，初始化容量为 10 ，初始化容量增量为 0 。

public Vector() {
this(10);
}

Vector(Collection<? extends E>)

创建一个 Vector 对象，初始化内容为集合 c 中的元素。

• 将数组 a 的长度赋给 elementCount ，集合 c 转换为数组 a，如果集合 c 是 ArrayList 对象，则将数组 a 直接赋给 elementData。
• 如果集合 c 不是 ArrayList 对象，则将数组 a 拷贝一份赋值给 elementData。

public Vector(Collection<? extends E> c) {
Object[] a = c.toArray();
elementCount = a.length;
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, elementCount, Object[].class);
}
}

copyInto(Object[])

将当前列表中的元素拷贝到指定数组 anArray 中，调用 System.arraycopy() 方法实现。

public synchronized void copyInto(Object[] anArray) {
System.arraycopy(elementData, 0, anArray, 0, elementCount);
}

trimToSize()

将当前列表的容量调整为列表的实际大小。

• modCount 是记录列表结构被修改的次数，定义在父类 AbstractList 中。
• 将列表按照实际存储元素的数量拷贝一份返回。

public synchronized void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (elementCount < oldCapacity) {
elementData = Arrays.copyOf(elementData, elementCount);
}
}

ensureCapacity(int)

确保数组中最少可以存放 minCapacity 个元素。

如果 minCapacity 大于当前列表长度，需要调用 grow 方法进行扩容。

public synchronized void ensureCapacity(int minCapacity) {
if (minCapacity > 0) {
modCount++;
if (minCapacity > elementData.length)
grow(minCapacity);
}
}

grow(int)

对列表进行扩容，确保列表中最少可以存放 minCapacity 个元素。

private Object[] grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = ArraysSupport.newLength(oldCapacity,
minCapacity - oldCapacity, /* minimum growth */
capacityIncrement > 0 ? capacityIncrement : oldCapacity
/* preferred growth */);
return elementData = Arrays.copyOf(elementData, newCapacity);
}

• 如果 capacityIncrement 的值大于零，则数组增加的长度为 capacityIncrement 的值，否则，数组长度增加为原来的二倍。
• 如果此时数组的长度仍然小于 minCapacity ，直接将数组的长度增加至 minCapacity 。
• 将数组中原来的元素拷贝到新的数组中。

grow()

对当前列表进行扩容，扩容后的最小长度为 elementCount+1 ，调用 grow(int) 方法实现。

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

setSize(int)

将当前列表中数组的元素个数设置为 newSize 。

• 如果当前数组长度小于 newSize ，先对数组进行扩容
• 将索引 newSize 及之后的元素都置为 null 。

public synchronized void setSize(int newSize) {
modCount++;
if (newSize > elementData.length)
grow(newSize);
final Object[] es = elementData;
for (int to = elementCount, i = newSize; i < to; i++)
es[i] = null;
elementCount = newSize;
}

其他方法和 ArrayList 中的方法差不多，只是在 Vector 中增加了 sychronized 关键字修饰。

更多源码分析，请点击

最后

以上就是无聊月饼为你收集整理的java源码分析---Vector类（JDK14）的全部内容，希望文章能够帮你解决java源码分析---Vector类（JDK14）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。