详解Java中的Vector

时间:2021-11-03 13:47:57

Vector实现了AbstractList抽象类和List接口,和ArrayList一样是基于Array存储的

Vector 是线程安全的,在大多数方法上存在synchronized关键字

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//Vector存放的元素,初始化默认长度为10
protected Object[] elementData;
//元素个数
protected int elementCount;
//每次扩容大小,默认为0
protected int capacityIncrement;
//构造函数,无指定初始化大小和无扩容大小
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;
}
//构造函数,Collection集合
public Vector(Collection<? extends E> c) {
  elementData = c.toArray();
  elementCount = elementData.length;
  if (elementData.getClass() != Object[].class)
    elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
  }
//确保扩容的最小容量
public synchronized void ensureCapacity(int minCapacity) {
  if (minCapacity > 0) {
    modCount++;
    ensureCapacityHelper(minCapacity);
  }
}
private void ensureCapacityHelper(int minCapacity) {
  // overflow-conscious code
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}
//扩容
private void grow(int minCapacity) {
  int oldCapacity = elementData.length;
  //当扩容大小为0的时候,扩容为原来的2倍
  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;
}
  • ensureCapacity(int minCapacity)方法确保Vector的最小长度,当扩容2倍小于minCapacity时,扩容到minCapacity大小,minCapacity不能小于0
  • 最大长度为2的31次方-1

设置大小

?
1
2
3
4
5
6
7
8
9
10
11
public synchronized void setSize(int newSize) {
  modCount++;
  if (newSize > elementCount) {
    ensureCapacityHelper(newSize);
  } else {
    for (int i = newSize ; i < elementCount ; i++) {
      elementData[i] = null;
    }
  }
  elementCount = newSize;
}

超过大小的被设置为Null

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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);
  }
}
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;
}

是否为空

?
1
2
3
public synchronized boolean isEmpty() {
  return elementCount == 0;
}

设置索引上的元素

?
1
2
3
4
5
6
7
public synchronized void setElementAt(E obj, int index) {
  if (index >= elementCount) {
    throw new ArrayIndexOutOfBoundsException(index + " >= " +
                         elementCount);
  }
  elementData[index] = obj;
}

添加元素

?
1
2
3
4
5
public synchronized void addElement(E obj) {
  modCount++;
  ensureCapacityHelper(elementCount + 1);
  elementData[elementCount++] = obj;
}

扩容

插入元素

?
1
2
3
4
5
6
7
8
9
10
11
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++;
}
  • 扩容
  • 数组拷贝向索引后移动
  • 删除为向前移动
  •  

删除元素

?
1
2
3
4
5
6
7
8
9
public synchronized boolean removeElement(Object obj) {
  modCount++;
  int i = indexOf(obj);
  if (i >= 0) {
    removeElementAt(i);
    return true;
  }
  return false;
}

只能删除第一个

-我是签名----------------------------
这里只是一个签名

详解

以上所述是小编给大家介绍的Java中的Vector,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持!

原文链接:http://www.cnblogs.com/imeng/archive/2017/10/18/7687091.html