Java集合【9】-- Vector源码解析

1.Vector介绍

Vector和前面说的ArrayList很是类似,这里说的也是1.8版本,它是一个队列,但是本质上底层也是数组实现的。同样继承AbstractList,实现了List,RandomAcess,Cloneable, java.io.Serializable接口。具有以下特点:

  • 提供随机访问的功能:实现RandomAcess接口,这个接口主要是为List提供快速访问的功能,也就是通过元素的索引,可以快速访问到。
  • 可克隆:实现了Cloneable接口
  • 是一个支持新增,删除,修改,查询,遍历等功能。
  • 可序列化和反序列化
  • 容量不够,可以触发自动扩容
  • **最大的特点是:线程安全的*,相当于线程安全的ArrayList

定义源码如下:

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ }

2. 成员变量

底层是数组,增加元素,数组空间不够的时候,需要扩容。

  • elementData:真正保存数据的数组
  • elementCount:实际元素个数
  • capacityIncrement:容量增加系数,就是扩容的时候增加的容量
  • serialVersionUID:序列化id
// 真正保存数据的数组 protected Object[] elementData; // 元素个数 protected int elementCount; //容量增加系数 protected int capacityIncrement; // 序列化id private static final long serialVersionUID = -2767605614048989439L;

3. 构造函数

Vector一共有四个构造函数:

  • 指定容量和增长系数
  • 指定容量
  • 不指定,使用默认容量值10
  • 指定集合初始化

1.指定容量和增长系数构造函数

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.指定初始化容量,增长系数默认为0

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

3.什么都不指定,默认给的容量是10:

public Vector() { this(10); }

4.指定集合初始化:

public Vector(Collection<? extends E> c) { // 转换成为数组 Object[] a = c.toArray(); // 大小为数组的大小 elementCount = a.length; // 如果是ArrayList,则直接复制 if (c.getClass() == ArrayList.class) { elementData = a; } else { // 否则需要进行拷贝 elementData = Arrays.copyOf(a, elementCount, Object[].class); } }

4. 常用方法

4.1 增加

增加元素,默认是在最后添加,如果容量不够的时候会触发扩容机制。

public synchronized void addElement(E obj) { // 修改次数增加 modCount++; // 确保容量足够(如果需要,里面会有扩容,复制操作) ensureCapacityHelper(elementCount + 1); // 将新元素放在最后一个元素,个数增加 elementData[elementCount++] = obj; }

那么它是如何确保容量的呢?
可以看到ensureCapacityHelper()里面判断增加后的元素个数是否大于现在数组的长度,如果不满足,就需要扩容。调用grow()函数扩容。

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; // 现在的容量,是以前的容量加上扩展系数,如果扩展系数小于等于0,那么,就是以前的容量的两倍 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); }

在指定的索引index,插入数据,实际上调用的是insertElementAt(element, index).

public void add(int index, E element) { insertElementAt(element, index); } // 调用插入元素的函数 public synchronized void insertElementAt(E obj, int index) { // 修改次数增加 modCount++; // 判断索引是否非法 if (index > elementCount) { throw new ArrayIndexOutOfBoundsException(index + " > " + elementCount); } // 确保容量足够 ensureCapacityHelper(elementCount + 1); // 拷贝数据,将后面的元素,往后移动一位 System.arraycopy(elementData, index, elementData, index + 1, elementCount - index); // 将实际的数据插入 elementData[index] = obj; // 个数增加 elementCount++; }

将一个集合所有元素添加进去:

public synchronized boolean addAll(Collection<? extends E> c) { // 修改次数增加 modCount++; // 转成数组 Object[] a = c.toArray(); // 数组的长度 int numNew = a.length; // 确保容量足够 ensureCapacityHelper(elementCount + numNew); // 拷贝 System.arraycopy(a, 0, elementData, elementCount, numNew); // 更新个数 elementCount += numNew; // 返回添加的数组是不是有数据 return numNew != 0; }

指定index,插入一个集合,和前面不一样的地方在于复制之前,需要计算往后面移动多少位,不是用for循环去插入,而是一次性移动和写入。

public synchronized boolean addAll(int index, Collection<? extends E> c) { // 修改次数增加 modCount++; // 合法判断 if (index < 0 || index > elementCount) throw new ArrayIndexOutOfBoundsException(index); // 转换数组 Object[] a = c.toArray(); // 插入数组长度 int numNew = a.length; // 确保数组的长度是否合法 ensureCapacityHelper(elementCount + numNew); // 移动的步长计算 int numMoved = elementCount - index; if (numMoved > 0) // 移动后面的元素,腾出位置给插入的元素 System.arraycopy(elementData, index, elementData, index + numNew, numMoved); // 插入元素 System.arraycopy(a, 0, elementData, index, numNew); // 更新个数 elementCount += numNew; // 插入元素个数是否为0 return numNew != 0; }

4.2 删除

删除指定元素

public boolean remove(Object o) { return removeElement(o); } // 实际调用的是removeElement() public synchronized boolean removeElement(Object obj) { // 修改次数增加 modCount++; // 获取第一个满足条件的元素缩影 int i = indexOf(obj); // 索引如果满足条件 if (i >= 0) { // 将索引为i的元素从数组中移除 removeElementAt(i); return true; } return false; } // 操作数组删除元素 public synchronized void removeElementAt(int index) { // 修改次数增加 modCount++; // 是否合法 if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); } else if (index < 0) { throw new ArrayIndexOutOfBoundsException(index); } // index后面的元素个数 int j = elementCount - index - 1; if (j > 0) { // 往前面移动一位(复制,覆盖) System.arraycopy(elementData, index + 1, elementData, index, j); } // 更新个数 elementCount--; // 原来最后一个元素的位置置空 elementData[elementCount] = null; /* to let gc do its work */ }

按照索引删除元素:

public synchronized E remove(int index) { // 修改次数增加 modCount++; // 合法性判断 if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); // 保存原来的数据 E oldValue = elementData(index); // 移动的个数 int numMoved = elementCount - index - 1; // 如果移动个数大于0 if (numMoved > 0) // 后面的元素往前面移动一位,赋值,覆盖 System.arraycopy(elementData, index+1, elementData, index, numMoved); // 最后一个元素置空 elementData[--elementCount] = null; // Let gc do its work // 返回旧的元素 return oldValue; }

4.3 修改

下面两个set函数都是,修改索引为index的元素,区别就是一个会返回旧的元素,一个不会返回旧的元素。

public synchronized E set(int index, E element) { // 合法性判断 if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); // 取出旧的元素 E oldValue = elementData(index); // 更新 elementData[index] = element; // 返回旧的元素 return oldValue; } public synchronized void setElementAt(E obj, int index) { // 合法哦性判断 if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); } // 直接更新 elementData[index] = obj; }

4.4 查询

public synchronized E get(int index) { // 合法判断 if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); // 返回数组的元素 return elementData(index); }

获取第一个元素:

public synchronized E firstElement() { if (elementCount == 0) { throw new NoSuchElementException(); } return elementData(0); }

获取最后一个元素:

public synchronized E lastElement() { if (elementCount == 0) { throw new NoSuchElementException(); } return elementData(elementCount - 1); } E elementData(int index) { return (E) elementData[index]; }

4.5 其他常用函数

将元素拷贝进数组中:

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

手动缩容,其实就是将里面的数组复制到一个更小的数组,更新数组引用即可。

public synchronized void trimToSize() { // 修改次数增加 modCount++; // 获取数组的长度 int oldCapacity = elementData.length; // 数组长度大于真实的容量,说明有可以缩容的空间 if (elementCount < oldCapacity) { // 复制到新的数组 elementData = Arrays.copyOf(elementData, elementCount); } }

保证容量的函数,其实相当于手动扩容,参数是所需要的最小的容量,里面调用的ensureCapacityHelper()在上面add()函数解析的时候已经说过了,不再解析。

public synchronized void ensureCapacity(int minCapacity) { if (minCapacity > 0) { modCount++; ensureCapacityHelper(minCapacity); } }

手动将元素个数设置为newSize,分为两种情况,一种是新的size比现在的size还要大,就是想到那个于指定容量扩容。另外一种是相当于缩容,但是这个缩容比较特殊,总的容量实际上没有变化,只是将里面多余的元素置为null。

public synchronized void setSize(int newSize) { modCount++; if (newSize > elementCount) { // 扩容 ensureCapacityHelper(newSize); } else { for (int i = newSize ; i < elementCount ; i++) { // 将超出个数的元素设置为null elementData[i] = null; } } elementCount = newSize; }

获取容量:

public synchronized int capacity() { return elementData.length; }

获取里面真实的元素个数:

public synchronized int size() { return elementCount; }

容器是不是为空:

public synchronized boolean isEmpty() { return elementCount == 0; }

返回枚举类型的元素迭代器,这是一个有意思的方法,相当于用枚举包装了当前的元素,Enumeration是一个接口,这个接口有两个方法,一个是hasMoreElements(),表示是否有下一个元素。一个是nextElement(),获取下一个元素。

public Enumeration<E> elements() { return new Enumeration<E>() { int count = 0; // 重写方法,是否有下一个元素 public boolean hasMoreElements() { return count < elementCount; } public E nextElement() { // 同步 synchronized (Vector.this) { if (count < elementCount) { // 返回下一个元素 return elementData(count++); } } throw new NoSuchElementException("Vector Enumeration"); } }; }

是否包含某一个元素,其实里面是获取对象的索引,如果索引大于等于0,证明元素在里面,否则元素不在里面。

public boolean contains(Object o) { return indexOf(o, 0) >= 0; }

返回元素的索引,分为两种情况,一种是元素是null的情况,不能使用equals()方法,另一种是非null,可以直接使用equals()方法。

public int indexOf(Object o) { return indexOf(o, 0); } public synchronized int indexOf(Object o, int index) { if (o == null) { for (int i = index ; i < elementCount ; i++) if (elementData[i]==null) return i; } else { for (int i = index ; i < elementCount ; i++) if (o.equals(elementData[i])) return i; } return -1; }

获取元素最后出现的索引位置,和前面一个不一样的是,这个需要从最后一个元素往前面查找

public synchronized int lastIndexOf(Object o) { return lastIndexOf(o, elementCount-1); } public synchronized int lastIndexOf(Object o, int index) { if (index >= elementCount) throw new IndexOutOfBoundsException(index + " >= "+ elementCount); if (o == null) { for (int i = index; i >= 0; i--) if (elementData[i]==null) return i; } else { for (int i = index; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; }

拷贝元素,数组里面的元素其实拷贝的只是引用,如果修改新的Vector里面的对象的属性,旧的也会被修改。

public synchronized Object clone() { try { @SuppressWarnings("unchecked") Vector<E> v = (Vector<E>) super.clone(); v.elementData = Arrays.copyOf(elementData, elementCount); v.modCount = 0; return v; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(e); } }

比如:

class Student { public int age; public String name; public Student(int age, String name) { this.age = age; this.name = name; } @Override public String toString() { return "Student{" + "age=" + age + ", name='" + name + '\'' + '}'; } } public class Test { public static void main(String[] args) { Vector<Student> vector1 = new Vector<>(); vector1.add(new Student(1,"sam")); Vector<Student> vector2 = (Vector<Student>) vector1.clone(); vector2.get(0).name = "change name"; System.out.println(vector2); System.out.println(vector1); }

输出结果如下,可以看出其实两个集合里面的Student还是同一个对象。

[Student{age=1, name='change name', score=0}] [Student{age=1, name='change name', score=0}]

将元素转换成为数组,原理也是一样,都是浅拷贝,拷贝的都是元素对象的引用。

public synchronized Object[] toArray() { return Arrays.copyOf(elementData, elementCount); }

指定数组类型的拷贝:

public synchronized <T> T[] toArray(T[] a) { if (a.length < elementCount) return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass()); System.arraycopy(elementData, 0, a, 0, elementCount); if (a.length > elementCount) a[elementCount] = null; return a; }

截取出某一段的元素集合,调用的是父类的方法

public synchronized List<E> subList(int fromIndex, int toIndex) { return Collections.synchronizedList(super.subList(fromIndex, toIndex), this); }

移除某一段索引的元素,我们可以看到首先是将后面的元素往前面移动,覆盖掉前面的元素,然后将后面的元素坑位赋值为null。

protected synchronized void removeRange(int fromIndex, int toIndex) { modCount++; int numMoved = elementCount - toIndex; // 复制到前面一段,将被移除的那一段覆盖,相当于后面元素整体前移 System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved); // Let gc do its work int newElementCount = elementCount - (toIndex-fromIndex); // 后面的坑位赋值为null while (elementCount != newElementCount) elementData[--elementCount] = null; }

获取指定位置的迭代器:
VectorArrayList基本差不多,都是定义了三个迭代器:

  • Itr:实现接口Iterator,有简单的功能:判断是否有下一个元素,获取下一个元素,删除,遍历剩下的元素
  • ListItr:继承Itr,实现ListIterator,在Itr的基础上有了更加丰富的功能。
  • VectorSpliterator:可以分割的迭代器,主要是为了分割以适应并行处理。和ArrayList里面的ArrayListSpliterator类似。
// 返回指定index位置的ListIterator public synchronized ListIterator<E> listIterator(int index) { if (index < 0 || index > elementCount) throw new IndexOutOfBoundsException("Index: "+index); return new ListItr(index); } // 返回开始位置的ListIterator public synchronized ListIterator<E> listIterator() { return new ListItr(0); } // 返回Itr public synchronized Iterator<E> iterator() { return new Itr(); } // 返回VectorSpliterator public Spliterator<E> spliterator() { return new VectorSpliterator<>(this, null, 0, -1, 0); }

4.6 Lambda表达式相关的方法

  • forEach:遍历处理
  • removeIf:按照条件移除元素
  • replaceAll:移除元素
  • sort:排序

基本都是将行为当成参数传递到函数中进行处理,里面值得一提的是removeIf(),里面是将过滤器传递进去,在里面我们可以看到使用了BitSet,这个东西来保存了需要移除的元素的下标,统计完成之后,后面再取出来进行移除操作。那么这个BitSet是什么呢???🤔🤔🤔🤔

一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。这和位向量(vector of bits)比较类似。
这是一个传统的类,但它在Java 2中被完全重新设计。

这样一看其实就是一个保存位值的类,可以设置为true,也可以取出来,这样就比较符合现在的场景,先遍历一次,把需要移除的元素用BitSet标记一下,然后再次遍历的时候,就复制元素,将这些坑位覆盖掉,就可以了。

@Override public synchronized void forEach(Consumer<? super E> action) { Objects.requireNonNull(action); final int expectedModCount = modCount; @SuppressWarnings("unchecked") final E[] elementData = (E[]) this.elementData; final int elementCount = this.elementCount; for (int i=0; modCount == expectedModCount && i < elementCount; i++) { // 对每一个元素进行处理 action.accept(elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } @Override @SuppressWarnings("unchecked") public synchronized boolean removeIf(Predicate<? super E> filter) { Objects.requireNonNull(filter); // figure out which elements are to be removed // any exception thrown from the filter predicate at this stage // will leave the collection unmodified int removeCount = 0; final int size = elementCount; // 按照当前的大小创建一个位值保存BitSet final BitSet removeSet = new BitSet(size); final int expectedModCount = modCount; for (int i=0; modCount == expectedModCount && i < size; i++) { @SuppressWarnings("unchecked") final E element = (E) elementData[i]; // 如果符合条件 if (filter.test(element)) { // 将指定索引处的位设置为 true。 removeSet.set(i); // 计算需要移除的个数 removeCount++; } } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } // shift surviving elements left over the spaces left by removed elements final boolean anyToRemove = removeCount > 0; if (anyToRemove) { // 移除后的大小 final int newSize = size - removeCount; for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) { // 返回第一个设置为 false 的位的索引,这发生在指定的起始索引或之后的索引上。 i = removeSet.nextClearBit(i); // 元素前移操作,覆盖被移除的元素的位置 elementData[j] = elementData[i]; } // 将后面的元素坑位置为null for (int k=newSize; k < size; k++) { elementData[k] = null; // Let gc do its work } elementCount = newSize; if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; } return anyToRemove; } @Override @SuppressWarnings("unchecked") public synchronized void replaceAll(UnaryOperator<E> operator) { Objects.requireNonNull(operator); final int expectedModCount = modCount; final int size = elementCount; for (int i=0; modCount == expectedModCount && i < size; i++) { // operator是操作,意思是将改操作应用于里面的每一个元素 elementData[i] = operator.apply((E) elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; } @SuppressWarnings("unchecked") @Override public synchronized void sort(Comparator<? super E> c) { final int expectedModCount = modCount; // 底层其实就是调用了数组的排序方法,将比较器c传递进去 Arrays.sort((E[]) elementData, 0, elementCount, c); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; }

4.7 如何遍历元素

遍历方法有一下几种:值得一说的是使用迭代器和使用枚举迭代器进行遍历。

Vector<String> myVector = new Vector<>(); // 第一种 for(String item:myVector){ System.out.println(item); } // 第二种 myVector.forEach(item-> System.out.println(item)); myVector.stream().forEach(new Consumer<String>() { @Override public void accept(String s) { System.out.println(s); } }); // 第三种 for(int index = 0;index<myVector.size();index++){ System.out.println(myVector.get(index)); } // 第四种 Iterator<String> iterator = myVector.iterator(); while(iterator.hasNext()){ System.out.println((String)iterator.next()); } // 第五种 Enumeration<String> enumeration = myVector.elements(); while(enumeration.hasMoreElements()){ System.out.println(enumeration.nextElement().toString()); }

5.序列化和反序列化

其实我们可以看到它的元素集合没有用transient来修饰,和ArrayList有所不同。

protected Object[] elementData;

但是它也重写了序列化的readObject()writeObject()两个方法。和ArrayList不同的是,序列化的时候将所有的数组里面的元素都序列化了,更加占用空间。
序列化的时候会序列化三个东西:

  • capacityIncrement:扩容增长系数
  • elementCount:元素个数
  • elementData: 数组元素
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { ObjectInputStream.GetField gfields = in.readFields(); int count = gfields.get("elementCount", 0); Object[] data = (Object[])gfields.get("elementData", null); if (count < 0 || data == null || count > data.length) { throw new StreamCorruptedException("Inconsistent vector internals"); } elementCount = count; elementData = data.clone(); } private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { final java.io.ObjectOutputStream.PutField fields = s.putFields(); final Object[] data; synchronized (this) { // 增长系数 fields.put("capacityIncrement", capacityIncrement); // 个数 fields.put("elementCount", elementCount); // 数组 data = elementData.clone(); } fields.put("elementData", data); s.writeFields(); }

6.迭代器

VectorArrayList基本差不多,都是定义了三个迭代器:

  • Itr:实现接口Iterator,有简单的功能:判断是否有下一个元素,获取下一个元素,删除,遍历剩下的元素
  • ListItr:继承Itr,实现ListIterator,在Itr的基础上有了更加丰富的功能。
  • VectorSpliterator:可以分割的迭代器,主要是为了分割以适应并行处理。和ArrayList里面的ArrayListSpliterator类似。

6.1 Itr

Itr这是一个比较初级的迭代器,实现了Iterator接口,有判断是否有下一个元素,访问下一个元素,删除元素的方法以及遍历对每一个元素处理的方法。
里面有两个比较重要的属性:

  • cursor:下一个即将访问的元素下标
  • lastRet:上一个返回的元素下标,初始化为-1

两个重要的方法:

  • next():获取下一个元素
  • remove():移除当前元素,需要在next()方法调用之后,才能调用,要不会报错。

ArrayList里面定义的基本差不多,除了这里面其实加上同步,因为要做到线程安全。

private class Itr implements Iterator<E> { // 下一个即将返回的元素index int cursor; // 上一个返回的index,-1则表示没有 int lastRet = -1; int expectedModCount = modCount; // 是否还有下一个元素 public boolean hasNext() { return cursor != elementCount; } // 获取下一个返回的元素 public E next() { // 同步 synchronized (Vector.this) { checkForComodification(); // 由于cursor本身就是下一个元素的下标,所以这个值直接取到,返回就可以,用i保存一下 int i = cursor; if (i >= elementCount) throw new NoSuchElementException(); // 下一个返回的index更新 cursor = i + 1; // 返回i位置的值,更新lastRet位置 return elementData(lastRet = i); } } // 移除元素 public void remove() { if (lastRet == -1) throw new IllegalStateException(); // 同步 synchronized (Vector.this) { checkForComodification(); // 调用Vector的移除方法 Vector.this.remove(lastet); expectedModCount = modCount; } // 删除了当前的元素,相当于迭代器倒退了一步 cursor = lastRet; // 上次返回的元素下标更新为-1,因为移除了 lastRet = -1; } // 遍历处理剩下的元素 @Override public void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); synchronized (Vector.this) { final int size = elementCount; int i = cursor; if (i >= size) { return; } @SuppressWarnings("unchecked") final E[] elementData = (E[]) Vector.this.elementData; if (i >= elementData.length) { throw new ConcurrentModificationException(); } // 对剩下的元素挨个处理 while (i != size && modCount == expectedModCount) { action.accept(elementData[i++]); } // update once at end of iteration to reduce heap write traffic cursor = i; lastRet = i - 1; checkForComodification(); } } // 检查是否被修改 final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } }

6.2 ListItr

拓展了Itr的功能,多了几个方法。
主要增加的功能有:

  • 根据index获取该位置的迭代器
  • 判断是否有前面的元素
  • 获取下一个返回元素的下标
  • 获取上一个返回元素的下面
  • 获取上一个元素
  • 更新元素
  • 增加元素

基本和ArrayList的也一样,也就修改的方法上加上了synchronized关键字进行同步。

final class ListItr extends Itr implements ListIterator<E> { ListItr(int index) { super(); cursor = index; } // 是否有上一个元素 public boolean hasPrevious() { return cursor != 0; } // 下一个元素下标 public int nextIndex() { return cursor; } // 上一个元素下标 public int previousIndex() { return cursor - 1; } // 获取上一个元素 public E previous() { // 同步 synchronized (Vector.this) { checkForComodification(); int i = cursor - 1; if (i < 0) throw new NoSuchElementException(); // 倒退了一步,所以cursor相当于减1 cursor = i; // 更新上一个元素index return elementData(lastRet = i); } } // 更新元素 public void set(E e) { if (lastRet == -1) throw new IllegalStateException(); synchronized (Vector.this) { checkForComodification(); Vector.this.set(lastRet, e); } } // 插入元素 public void add(E e) { int i = cursor; synchronized (Vector.this) { checkForComodification(); Vector.this.add(i, e); expectedModCount = modCount; } // 插入元素之后,下一个元素的下标相当加1,因为它们相当于后移了 cursor = i + 1; lastRet = -1; } }

6.3 VectorSpliterator

直接看源码,这是一个用来适应多线程并行迭代的迭代器,可以将集合分成多端,进行处理,每一个线程执行一段,那么就不会相互干扰,它可以做到线程安全。

对标ArrayListSpliterator,里面的实现基本一样。

static final class VectorSpliterator<E> implements Spliterator<E> { private final Vector<E> list; private Object[] array; // 当前位置 private int index; // 结束位置,-1表示最后一个元素 private int fence; // -1 until used; then one past last index private int expectedModCount; // initialized when fence set /** Create new spliterator covering the given range */ VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence, int expectedModCount) { this.list = list; this.array = array; this.index = origin; this.fence = fence; this.expectedModCount = expectedModCount; } private int getFence() { // initialize on first use int hi; if ((hi = fence) < 0) { synchronized(list) { array = list.elementData; expectedModCount = list.modCount; hi = fence = list.elementCount; } } return hi; } // 分割,每调用一次,将原来的迭代器等分为两份,并返回索引靠前的那一个子迭代器。 public Spliterator<E> trySplit() { int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; return (lo >= mid) ? null : new VectorSpliterator<E>(list, array, lo, index = mid, expectedModCount); } // 返回true时,表示可能还有元素未处理 // 返回falsa时,没有剩余元素处理了 @SuppressWarnings("unchecked") public boolean tryAdvance(Consumer<? super E> action) { int i; if (action == null) throw new NullPointerException(); if (getFence() > (i = index)) { index = i + 1; action.accept((E)array[i]); if (list.modCount != expectedModCount) throw new ConcurrentModificationException(); return true; } return false; } // 遍历处理剩下的元素 @SuppressWarnings("unchecked") public void forEachRemaining(Consumer<? super E> action) { int i, hi; // hoist accesses and checks from loop Vector<E> lst; Object[] a; if (action == null) throw new NullPointerException(); if ((lst = list) != null) { if ((hi = fence) < 0) { synchronized(lst) { expectedModCount = lst.modCount; a = array = lst.elementData; hi = fence = lst.elementCount; } } else a = array; if (a != null && (i = index) >= 0 && (index = hi) <= a.length) { while (i < hi) action.accept((E) a[i++]); if (lst.modCount == expectedModCount) return; } } throw new ConcurrentModificationException(); } // 估算大小 public long estimateSize() { return (long) (getFence() - index); } // 返回特征值 public int characteristics() { return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED; } }

几个迭代器,各有各自的功能,我们按需使用即可🌝🌝🌝

7. 小结一下

Vector的思路和ArrayList基本是相同的,底层是数组保存元素,Vector 默认的容量是10,有一个增量系数,如果指定,那么每次都会增加一个系数的大小,否则就扩大一倍。

扩容的时候,其实就是数组的复制,其实还是比较耗时间的,所以,我们使用的时候应该尽量避免比较消耗时间的扩容操作。

和ArrayList最大的不同,是它是线程安全的,几乎每一个方法都加上了Synchronize关键字,所以它的效率相对也比较低一点。
ArrayList如果需要线程安全,可以使用List list = Collections.synchronizedList(new ArrayList(...));这个方法。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

技术之路不在一时,山高水长,纵使缓慢,驰而不息。

公众号:秦怀杂货店


__EOF__

本文作者秦怀杂货店
本文链接https://www.cnblogs.com/Damaer/p/13992162.html
关于博主:评论和私信会在第一时间回复。或者直接私信我。
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!
声援博主:如果您觉得文章对您有帮助,可以点击文章右下角推荐一下。您的鼓励是博主的最大动力!
posted @   第十六封  阅读(175)  评论(0编辑  收藏  举报
编辑推荐:
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· .NET Core 托管堆内存泄露/CPU异常的常见思路
· PostgreSQL 和 SQL Server 在统计信息维护中的关键差异
· C++代码改造为UTF-8编码问题的总结
· DeepSeek 解答了困扰我五年的技术问题
阅读排行:
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· 清华大学推出第四讲使用 DeepSeek + DeepResearch 让科研像聊天一样简单!
· 实操Deepseek接入个人知识库
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
点击右上角即可分享
微信分享提示