更多源码分析，请点击
Vector
Vector 和 ArrayList 原理实现差不多，但是 Vector 是 线程安全 的，在效率上没有 ArrayList 高，因为为保证线程安全，使用 synchronized 关键字修饰方法。
Vector 底层采用 Object 数组来保存数据，所以如果要保存基本类型需要使用他们的包装类。
1
2
3
4
5
6
7
8
9public 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 。
1
2
3
4
5
6
7
8
9public 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 。
1
2
3
4public Vector(int initialCapacity) { this(initialCapacity, 0); }
Vector()
构造函数 ，创建一个 Vector 对象，初始化容量为 10 ，初始化容量增量为 0 。
1
2
3
4public Vector() { this(10); }
Vector(Collection<? extends E>)
创建一个 Vector 对象，初始化内容为集合 c 中的元素。
- 将数组 a 的长度赋给 elementCount ，集合 c 转换为数组 a，如果集合 c 是 ArrayList 对象，则将数组 a 直接赋给 elementData。
- 如果集合 c 不是 ArrayList 对象，则将数组 a 拷贝一份赋值给 elementData。
1
2
3
4
5
6
7
8
9
10public 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() 方法实现。
1
2
3
4public synchronized void copyInto(Object[] anArray) { System.arraycopy(elementData, 0, anArray, 0, elementCount); }
trimToSize()
将当前列表的容量调整为列表的实际大小。
- modCount 是记录列表结构被修改的次数，定义在父类 AbstractList 中。
- 将列表按照实际存储元素的数量拷贝一份返回。
1
2
3
4
5
6
7
8public synchronized void trimToSize() { modCount++; int oldCapacity = elementData.length; if (elementCount < oldCapacity) { elementData = Arrays.copyOf(elementData, elementCount); } }
ensureCapacity(int)
确保数组中最少可以存放 minCapacity 个元素。
如果 minCapacity 大于当前列表长度，需要调用 grow 方法进行扩容。
1
2
3
4
5
6
7
8public synchronized void ensureCapacity(int minCapacity) { if (minCapacity > 0) { modCount++; if (minCapacity > elementData.length) grow(minCapacity); } }
grow(int)
对列表进行扩容，确保列表中最少可以存放 minCapacity 个元素。
1
2
3
4
5
6
7
8
9private 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) 方法实现。
1
2
3
4private Object[] grow() { return grow(elementCount + 1); }
setSize(int)
将当前列表中数组的元素个数设置为 newSize 。
- 如果当前数组长度小于 newSize ，先对数组进行扩容
- 将索引 newSize 及之后的元素都置为 null 。
1
2
3
4
5
6
7
8
9
10public 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）内容请搜索靠谱客的其他文章。
发表评论 取消回复