Vector的add(Object obj)和remove(Object obj)和remove(index)和get(index)的源码分析

1.add(Object obj)

//构造器Vector()
	
	Vector v1 = new Vector();
		v1.add(1);
		v1.add(2);
		v1.add(3);
		v1.add(4);
		v1.add(5);
		v1.add(6);
		v1.add(7);
		v1.add(8);
		v1.add(9);
		v1.add(10);
		v1.add(11);

	//无参构造器，初始化Vector,数组长度为10
	 public Vector() {
		this(10);
	}
	//一个参数的构造函数
	public Vector(int initialCapacity) {
		//initialCapacity  = 10 
        this(initialCapacity, 0);
    }

	//两个参数的构造函数
	public Vector(int initialCapacity, int capacityIncrement) {
		//initialCapacity = 10   capacityIncrement = 0
        super();
        if (initialCapacity < 0)
			//如果initialCapacity < 0，会抛出IllegalArgumentException异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
		 
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

	


	   //元素为int类型,所以进行装箱
	 public static Integer valueOf(int i) {
			if (i >= IntegerCache.low && i <= IntegerCache.high)
				return IntegerCache.cache[i + (-IntegerCache.low)];
		}
	 }

	//此add方法加上了synchronized,所以为线程安全的
	 public synchronized boolean add(E e) {
        modCount++;//计数器
		//elementCount = 0
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

	 private void ensureCapacityHelper(int minCapacity) {
        //minCapacity = 1
		//elementData.length = 10  
		//elementData = [null, null, null, null, null, null, null, null, null, null]
		//所以前十个元素不进行数组扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

	....
	
	//第十一个元素开始

	 //元素为int类型,所以进行装箱
	 public static Integer valueOf(int i) {
			if (i >= IntegerCache.low && i <= IntegerCache.high)
				return IntegerCache.cache[i + (-IntegerCache.low)];
		}
	 }

	  public synchronized boolean add(E e) {
        modCount++;
		//elementCount = 10
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

	 private void ensureCapacityHelper(int minCapacity) {
        //minCapacity = 11
		//elementData.length = 10
		//成立,进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

	private void grow(int minCapacity) {
		//minCapacity = 11
		//elementData.length = 10
		//oldCapacity = 10
        int oldCapacity = elementData.length;

		//capacityIncrement = 0
		//所以 newCapacity = 20
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
		//不成立。
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
		//不成立.
		//private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
		//成立的话,数组会溢出
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
		//实现数组的复制,把新的数组替换点旧的.数组得到扩容.变为原来的2倍
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


	
	//综上分析:当初始化Vector时,底层数组的长度为10,当向里面添加第一个元素时,数组的长度变还为10,当
	//数组长度大于10时,数组会进行扩容.经分析,每次扩容新的长度为原来的2倍  所以第二次扩容为20,第三次为40
	//到此,ArrayList的add(Object) 源码分析完

2.get(int index)  得到下标为index位置上的元素

//加上了synchronized,所以为线程安全的
	public synchronized E get(int index) {
		//判断下标是否大于元素长度,否则排除数组越界异常
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }
	
	//返回下标为index的元素
	E elementData(int index) {
        return (E) elementData[index];
    }

3.remove(int index),返回值为Object类型

public E remove(int index) {
				modCount++;//计数器
				//index:传入要删除元素的位置,假设下标为2,即index=2
				
				//检查index是否越界
				 if (index >= elementCount)
				throw new ArrayIndexOutOfBoundsException(index);

				//得到下标为index的元素,值为oldValue
				E oldValue = elementData(index);

				//此时数组的长度为11,size=11,index=2,所以numMoved=8
				int numMoved = size - index - 1;

				 //arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
				 //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
				 //第一个elementData:原数组
				 //第二个elementData：目标数组
				 //源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。 
				 //public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
				if (numMoved > 0)
					System.arraycopy(elementData, index+1, elementData, index,
									 numMoved);
				//此时最后的一个元素设为nul，这是数组的长度就减1了
				elementData[--size] = null; // clear to let GC do its work

				//返回删除的元素
				return oldValue;
			}

			
			 private void rangeCheck(int index) {
				 //当index大于数组的长度时,会抛出数组下标越界异常.
				if (index >= size)
				throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
			 }

4.remove(Object obj),当遇到要删除的对象为int类型时，要把该int类型的值进行装箱,变为Integer类型

public Integer(int value) {
			this.value = value;
		}

		public boolean remove(Object o) {
			return removeElement(o);
		}

		//加上synchronized,线程安全的
		public synchronized boolean removeElement(Object obj) {
			modCount++;
			//记录obj在第几个位置
			int i = indexOf(obj);
			//如果大于0
			if (i >= 0) {
				removeElementAt(i);
				return true;
			}
			return false;
	  }

		
	  public synchronized void removeElementAt(int index) {
        modCount++;

		//如果要删除的下标大于数组长度,则抛出数组下标越界异常
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
		//如果要删除的下标小于0,则抛出数组下标越界异常
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }

		 //arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
		 //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
		 //第一个elementData:原数组
		 //第二个elementData：目标数组
		 //源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。 
		 //public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
		//最后一个位置上的元素设置为null
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }