java类创建自身对象(java类里面初始化自身)

00-1010和之前一样，所以我们先来看前面的UML类图。

向量的初始化构造方法

无参数构造(默认调用初始化容量的构造方法，默认容量为10)

public Vector(){ 0

//这里将调用带有容量参数的Vector的构造函数方法。默认容量为10。

//在这里，与ArrayList不同，ArrayList在调用add方法之前不会初始化容量。

这(10)；

}

指定初始化容量大小。

公共向量(int initial Capacity){ 0

//这里，调用下面指定的初始化容量和增长系数的构造方法。默认增长系数为0。

这(initialCapacity，0)；

}

指定初始容量和增长系数

公共向量(整数容量，整数容量)

super()；

//容量不能小于0

if(初始电容0)

引发新的IllegalArgumentException('非法容量： '

initial capacity)；

//指定对象数组的初始化容量

this.elementData=新对象[initial capacity]；

//设置生长因子

this . capacity increment=capacity increment；

}

使用另一个集合来构造集合。

公共向量(集合？扩展了E(c){ 0

//将传入集合转换为数组

element data=c . to array()；

//Vector的元素个数是集合的长度。

element count=element data . length；

//c.toArray可能(错误地)不会返回Object[](参见6260652)

//确定添加的元素对象是否为对象数组类型。

if (elementData.getClass()！=对象[]。类)

//制作一个浅拷贝，将类型转换为对象数组。

element data=arrays . copy of(element data，elementCount，Object[])。类)；

}

Add(E e)方法公共同步布尔add(E E){ 0

//更新操作的次数

modCount

//保证元素的容量可以节省，必要时可以扩容。

ensureCapacityHelper(element count 1)；

element data[element count]=e；

返回真；

}

//如有必要，增加当前数组的容量，以确保至少可以保存minCapacity capacity参数指定的元素数量。

私有void ensureCapacityHelper(int minCapacity){ 0

//有溢出意识的代码

if(MinCapacity-ElEMENTDATa . length 0)

//矢量的//容量扩展方法

增长(最小容量)；

}

//容量扩展方法

私有void grow(int MinCapability){ 0

//有溢出意识的代码

//原始矢量容量值

int old capacity=element data . length；

//如果为capacityIncrement设置了增长系数，则添加系数值以扩展容量，否则，将原始阵列容量更改为2*oldCapacity。

int new capacity=old capacity((capacity increment 0)？

capacity increment : old capacity)；

//如果复位容量值小于最小要求容量值。

if(新容量-最小容量

ty <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;
}

add(int index, E element)方法（指定位置添加元素）

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++;
}

addAll(Collection c)方法

public synchronized boolean addAll(Collection 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;
}
remove(int index)方法public synchronized E remove(int index) {
modCount++;
//对index进行边界检查
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;
}

remove(Object o)方法

public boolean remove(Object o) {
//调用removeElement(Object obj)方法
return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
//更新操作次数
modCount++;
//得到要删除元素的坐标
int i = indexOf(obj);
if (i >= 0) {
//根据坐标删除元素
removeElementAt(i);
return true;
}
return false;
}
public synchronized void removeElementAt(int index) {
modCount++;
//对index进行边界检查
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 */
}

removeAll(Collection c)方法

//删除指定集合中的所有元素
public synchronized boolean removeAll(Collection c) {
//调用AbstractCollection中的removeAll的方法
return super.removeAll(c);
}

retainAll(Collection c)方法

//删除非集合c中的元素
public synchronized boolean retainAll(Collection c) {
return super.retainAll(c);
}

clear()方法

public void clear() {
//清空集合方法调用上面removeAllElements方法
removeAllElements();
}
get(int index)方法public synchronized E get(int index) {
//对index进行边界检查
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
//根据下标获取元素
return elementData(index);
}
E elementData(int index) {
//在数组中根据下标获取元素
return (E) elementData[index];
}
set(int index, E element)方法public synchronized E set(int index, E element) {
//对index进行边界检查
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
//获取index坐标的元素
E oldValue = elementData(index);
//将set的元素放入数组指定下标
elementData[index] = element;
return oldValue;
}

总结：

Vector是使用数组保存数据，和ArrayList一样在无参的构造方法中,默认的初始容量为10，增长系数为0比ArrayList多了一个增长系数的概念Vector类是线程安全的List,其底层是通过Synchronized关键字实现的(同步方法)，ArrayList是线程不安全的扩容机制：如果增长系数不位 0 那么就是当前容量 + 增长系数，否则就是2倍，ArrayList为1.5倍左右