JAVA深入集合--Vector

一．介绍

Vector 本质是一个数组，当然他具有数组的通过下标访问等特性，同时这玩意儿继承了 AbstractList 。当然他具有了集合的通用功能，同时他实现了 List,RandomAccess,Cloneable ,Sertializable 接口。

这里大概提一下RandomAccess 和 Cloneable 。

1.1 RandomAccess 可以让其拥有随机访问的能力，可以用迭代器进行迭代，某些情况 下 会有更好性能。没有就无法使用Iterator迭代器。

 

1.2 Cloneable 会提供Object 的clone 功能，没有就无法clone。

 

 

 

 

关于这里的研究我们以后再谈，还是先来说Vector 。

 

 

二．代码分析

 

2.1 Vector 的属性 :
     protected Object[] elementData; 这是用来存放元素的。
     protected int elementCount; 这是记录这个对象存放了好多个元素
     protected int capacityIncrement； 这是增长因子，就是你数组放不下了，增加容量。

2.2 构造方法：
     public Vector() {
	  this(10);
　　}
　　
    public Vector(int initialCapacity, int capacityIncrement) {
	     this.elementData = new Object[initialCapacity];
	     this.capacityIncrement = capacityIncrement;
　　 }
　　
     public Vector(int initialCapacity) {
	    this(initialCapacity, 0);
　　 }
　　
     这里我取了主要部分，从构造不难看出，我们默认 new Vector()，实际上是通过public Vector(int initialCapacity, int capacityIncrement) 方法，创建了长度为10 ，增长因子为0 的Object 数组。这里如果大概知道数组长度，请指定长度，必然复制数组带来的开销。



public Vector(Collection<? extends E> c) {
	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);
    }

这个构造 是把集合元素存放到Vector对象里面。

 

3.3 方法介绍：这里只介绍几个主要的，其余可以查询API


public synchronized boolean add(E e) {
	modCount++;
	ensureCapacityHelper(elementCount + 1);
	elementData[elementCount++] = e;
        return true;
　　}
　　
 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);
	}
    }

 方法：add(E e)：

      就是添加一个元素，这里通过ensureCapacityHelper 方法进行判断添加的个数，从ensureCapacityHelper(elementCount + 1);知道，默认是添加一个，这里添加的个数如果超出了原来数组的长度，就用Arrays.copyOf 进行扩容，底层用的System.arraycopy 方法，默认元素加载末尾。关于 modCount 字段是集合用来快速判断迭代过程中失败的标志，也就是说 如果集合在地带过程中，进行了删除等操作 就会报错。

 

同理：
　　方法：add(int index,E element) 向指定位置添加元素，实际上访问的是：
　　 
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++;
　　    }
但是你发现 最终都是 调用 ensureCapacityHelper 等方法。

还有： public synchronized void addElement(E obj) 方法，和add方法相比，只是返回值不一样，一个是boolean,一个是 void 内部完全一样。


方法： public boolean contains(Object o) 判断元素是否存在，实际访问的是：
 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 Enumeration<E> elements()
这里是创建了一个枚举类型，里面实现还是通过元素是否存在，通过下标遍历数组

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 (E)elementData[count++];
		    }
		}
		throw new NoSuchElementException("Vector Enumeration");
	    }
	};
　　    }
　　
　　
　　当然还有其他方法，就不多做介绍了，就是数组元素的操作而已。

 

小结：

1.Vector 本质是一个数组，其实所有集合都是数组，从JAVA 来说搞成了对象，符合我  们的OO，可以参考学习。

2.Vector 源码看出很多方法都是synchronized 的，线程安全，但是效率就不得不  损耗点了，多线程开发可以使用。

允许的情况，我们可以参考这种模式，设计自己的vector 类，或者其他类，以便于更适应我们的项目。不要把这些看得很圣神，其实都是你和JDK开发人员，差距没那么大，相信自己。