Vector的浅析-白红宇

Vector的浅析

阅读量：6647 次

发布时间：2019-06-25

本文共 7598 字，大约阅读时间需要 25 分钟。

　　Vector 可实现自动增长的对象数组。java.util.vector 提供了向量类(vector)以实现类似动态数组的功能。在Java语言中没有指针的概念，但如果正确灵活地使用指针又确实可以大大提高程序的质量。Java提供了丰富的类库来方便编程者使用，vector类便是其中之一。事实上，灵活使用数组也可以完成向量类的功能，但向量类中提供大量的方法大大方便了用户的使用。创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况。可以考虑使用向量类。

　　Vector每次默认扩充为原来的2倍，ArrayList默认扩充为原来的1.5倍。Vector是同步的，ArrayList不是同步的。

　　Vector类的核心声明如下：

public class Vector
     
       extends AbstractList
      
        implements List
       
        ,		RandomAccess, Cloneable, java.io.Serializable {	protected Object[] elementData;// 保存Vector中数据的数组	protected int elementCount;// 实际数据的数量	protected int capacityIncrement;// 容量增长系数	private static final long serialVersionUID = -2767605614048989439L;}

　　Vector类具有构造函数：

　　　　　public Vector() {		this(10);	}	// 指定Vector容量大小的构造函数	public Vector(int initialCapacity) {		this(initialCapacity, 0);	}	// 指定Vector"容量大小"和"增长系数"的构造函数	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构造函数。	public Vector(Collection
      c) {		// 获取“集合(c)”的数组，并将其赋值给elementData		elementData = c.toArray();		// 设置数组长度		elementCount = elementData.length;		// c.toArray might (incorrectly) not return Object[] (see 6260652)		if (elementData.getClass() != Object[].class)			elementData = Arrays.copyOf(elementData, elementCount,Object[].class);	}

　　其他代码：

public class Vector
     
       extends AbstractList
      
        implements List
       
        ,		RandomAccess, Cloneable, java.io.Serializable {	...	// 将数组Vector的全部元素都拷贝到数组anArray中	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);		}	}	private void ensureCapacityHelper(int minCapacity) {		int oldCapacity = elementData.length;		if (minCapacity > oldCapacity) {			Object[] oldData = elementData;			int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement)					: (oldCapacity * 2);			if (newCapacity < minCapacity) {				newCapacity = minCapacity;			}			elementData = Arrays.copyOf(elementData, newCapacity);		}	}	public synchronized void ensureCapacity(int minCapacity) {		modCount++;		ensureCapacityHelper(minCapacity);	}	// 设置容量值为 newSize	public synchronized void setSize(int newSize) {		modCount++;		if (newSize > elementCount) {			// 若 "newSize 大于 Vector容量"，则调整Vector的大小。			ensureCapacityHelper(newSize);		} else {			// 若 "newSize 小于/等于 Vector容量"，则将newSize位置开始的元素都设置为null			for (int i = newSize; i < elementCount; i++) {				elementData[i] = null;			}		}		elementCount = newSize;	}　　	...	// 返回“Vector中全部元素对应的Enumeration”	public Enumeration
        
          elements() {		// 通过匿名类实现Enumeration		return new Enumeration
         
          () {			int count = 0;			// 是否存在下一个元素			public boolean hasMoreElements() {				return count < elementCount;			}			// 获取下一个元素			public E nextElement() {				synchronized (Vector.this) {					if (count < elementCount) {						return (E) elementData[count++];					}				}				throw new NoSuchElementException("Vector Enumeration");			}		};	}		// 删除index位置的元素	public synchronized void removeElementAt(int index) {		modCount++;		if (index >= elementCount) {			throw new ArrayIndexOutOfBoundsException(index + " >= "+ elementCount);		} else if (index < 0) {			throw new ArrayIndexOutOfBoundsException(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 */	}	// 在index位置处插入元素(obj)	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++;	}	// 在Vector中查找并删除元素obj。	// 成功的话，返回true；否则，返回false。	public synchronized boolean removeElement(Object obj) {		modCount++;		int i = indexOf(obj);		if (i >= 0) {			removeElementAt(i);			return true;		}		return false;	}	// 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型	public synchronized 
          
            T[] toArray(T[] a) { // 若数组a的大小 < Vector的元素个数； // 则新建一个T[]数组，数组大小是“Vector的元素个数”，并将“Vector”全部拷贝到新数组中 if (a.length < elementCount) return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass()); // 若数组a的大小 >= Vector的元素个数； // 则将Vector的全部元素都拷贝到数组a中。 System.arraycopy(elementData, 0, a, 0, elementCount); if (a.length > elementCount) a[elementCount] = null; return a; } // 设置index位置的值为element。并返回index位置的原始值 public synchronized E set(int index, E element) { if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); Object oldValue = elementData[index]; elementData[index] = element; return (E) oldValue; } // 删除Vector中的元素o public boolean remove(Object o) { return removeElement(o); } // 在index位置添加元素element public void add(int index, E element) { insertElementAt(element, index); } // 删除index位置的元素，并返回index位置的原始值 public synchronized E remove(int index) { modCount++; if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); Object oldValue = elementData[index]; int numMoved = elementCount - index - 1; if (numMoved > 0) System.arraycopy(elementData, index + 1, elementData, index, numMoved); elementData[--elementCount] = null; // Let gc do its work return (E) oldValue; } // 返回Vector是否包含集合c public synchronized boolean containsAll(Collection
            c) { return super.containsAll(c); } // 将集合c添加到Vector中 public synchronized boolean addAll(Collection
            c) { modCount++; Object[] a = c.toArray(); int numNew = a.length; ensureCapacityHelper(elementCount + numNew); // 将集合c的全部元素拷贝到数组elementData中 System.arraycopy(a, 0, elementData, elementCount, numNew); elementCount += numNew; return numNew != 0; } // 删除集合c的全部元素 public synchronized boolean removeAll(Collection
            c) { return super.removeAll(c); } // 删除“非集合c中的元素” public synchronized boolean retainAll(Collection
            c) { return super.retainAll(c); } // 从index位置开始，将集合c添加到Vector中 public synchronized boolean addAll(int index, Collection
            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; return numNew != 0; } // 获取Vector中fromIndex(包括)到toIndex(不包括)的子集 public synchronized List
           
             subList(int fromIndex, int toIndex) { return Collections.synchronizedList(super.subList(fromIndex, toIndex),this); } // 删除Vector中fromIndex到toIndex的元素 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); while (elementCount != newElementCount) elementData[--elementCount] = null; } // java.io.Serializable的写入函数 private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { s.defaultWriteObject(); }}

转载地址：http://tcrvo.baihongyu.com/

你可能感兴趣的文章