一、学习目的
由于最近在项目中发现，一个项目中用到的java中最多也是最重要的知识基本上就是集合类的使用和多线程的开发，而集合类基本都会使用像List、ArrayList或者HashMa，有些场景可能会用到HashTable或者HashSet等集合。总的来说，java中的对于集合的操作给我们编程带来了很大的便利，但是作为一名合格的程序员，我觉得不仅要会使用，而且应该知道实现细节。同时阅读技术牛人写出来的代码对于自己的开发水平也会有很大的帮助。
二、学习目标
了解Vector的继承关系以及其内部实现，能够更加灵活的使用
三、学习笔记
在java的代码实现中，如果你去认真观察的话，他的继承关系有些复杂，也可以说有些冗余，但是到目前为止我还不知道为什么会有这种冗余出现，或者是代码开发者不小心造成的，也有可能是代码开发者故意这么写，让我们在看代码的时候不用那么麻烦吧.具体的也说不清，下面看一些java中关于vector实现的类图：
在上面的类图中，基本上所有的集合类都会实现Collection接口，并且每一个集合类中都会实现自己的迭代器函数，用于循环遍历，必要时候可以使用迭代器进行删除某个迭代器指向的元素。我并没有将所有的类方法写到里面，这个类图主要是想让读者能够看到清晰的继承关系。从图中可以看到Vector继承了AbstractList<E>这个抽象类，但同时AbstractList又实现了List<E>接口，但Vector也实现了List<E>接口，这个地方总感觉有些多余.如果有知道的还请指导。通过接口的继承关系以及Vector的实现关系，可以理解为Vector类实现了以下接口：Iterable、Collection、List、RandomAccess、Cloneable、Serializable。上述接口在以后的学习过程中还会学到，这篇文章中就不深入了解其细节了，只要大概知道是干什么的就行。
下面就是关于代码层面的学习：
在java.util包中打开Vector.java这个类，首先类名以及继承代码
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializableprotected Object[] elementData;下面看一下该类中主要的方法都有哪些：
1. size 方法的实现
public synchronized int size() {
return elementCount;
}返回Vector中元素个数，这边的元素个数与数组大小不是一个概念。vector中元素个数是通过
<pre name="code" class="java">protected int elementCount;<pre name="code" class="java">public synchronized boolean isEmpty() {
return elementCount == 0;
}3. boolean contains(Object o);//是否包含某个对象
public boolean contains(Object o) {
return indexOf(o, 0) >= 0;
}4. index方法的实现
<pre name="code" class="java">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;
}5.lastIndexOf方法的实现
<pre name="code" class="java">public synchronized int lastIndexOf(Object o, int index) {
if (index >= elementCount)
throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
if (o == null) {
for (int i = index; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = index; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}6.elementAt，firstElement，lastElement方法
<pre name="code" class="java">public synchronized E elementAt(int index) {
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
}
return elementData(index);
}7.elementData方法的实现
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}8.removeElementAt方法的实现
在寻找第7个方法的时候我无意间看到了一个很好的实现方法。确实感觉到了在java中无处不在的代码重用。不废话了，看代码
<pre name="code" class="java">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 */
}在system类中实现的arraycopy方法直接把这个删除方法搞定，这个方法中的参数代表什么意思呢？第一个参数表示源数组，第二个参数源数组的开始位置，第三个参数表示目的数组，第四个参数表示目的数组的开始位置，第五个参数表示复制多少个数据过去。认真思考后发现，这样拷贝的话，那么源数组中的最后一个元素并没有替换，还是存在原来的位置，且与倒数第二个位置上的元素相同。这样的话删除的不完全啊。对，确实这样操作删除的不完全，但是后面的两句话将arraycopy的缺点给弥补了.好巧妙。
9.clone方法的实现
<pre name="code" class="java">public synchronized Object clone() {
try {
@SuppressWarnings("unchecked")
Vector<E> v = (Vector<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, elementCount);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}10. addAll函数的实现
<pre name="code" class="java">public synchronized boolean addAll(Collection<? extends E> 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;
}<pre name="code" class="java">ensureCapacityHelper(elementCount + numNew);而集合中全部都有toArray方法，下面就直接看一下Vector中的toArray方法吧
11 toArray方法的实现
<span style="font-family:KaiTi_GB2312;font-size:14px;"></span><pre name="code" class="java">public synchronized Object[] toArray() {
return Arrays.copyOf(elementData, elementCount);
}12 扩容函数ensureCapacityHelper的实现
<span style="font-family:KaiTi_GB2312;font-size:14px;"></span><pre name="code" class="java">private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}<pre name="code" class="java"> private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
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;
}这部分代码也没有什么好解释的了,每一个集合类都有自己不同的扩容方法，根据集合的性能不同，使用了不同的方法，从这部分代码能够看到扩容的主要因子是capacityIncrement，容量增量。同时该扩容算法的容器增长率是呈线性增长的。
13.唯一一个实现的是Serilizable接口中的方法
<pre name="code" class="java">private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
final java.io.ObjectOutputStream.PutField fields = s.putFields();
final Object[] data;
synchronized (this) {
fields.put("capacityIncrement", capacityIncrement);
fields.put("elementCount", elementCount);
data = elementData.clone();
}
fields.put("elementData", data);
s.writeFields();
}将对象中的字段以及值放入到流中，进行数据的传输。这里也不在说明了，以后肯定还会遇到序列化接口的实现的。
14.listIterator的实现
上面就曾经说过，每一个集合类中都会存在一个迭代器，方便对集合中元素进行操作
<pre name="code" class="java">public synchronized Iterator<E> iterator() {
return new Itr();
}
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
// Racy but within spec, since modifications are checked
// within or after synchronization in next/previous
return cursor != elementCount;
}
public E next() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor;
if (i >= elementCount)
throw new NoSuchElementException();
cursor = i + 1;
return elementData(lastRet = i);
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this) {
checkForComodification();
Vector.this.remove(lastRet);
expectedModCount = modCount;
}
cursor = lastRet;
lastRet = -1;
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/**
* An optimized version of AbstractList.ListItr
*/
final class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
public E previous() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
cursor = i;
return elementData(lastRet = i);
}
}
public void set(E e) {
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this) {
checkForComodification();
Vector.this.set(lastRet, e);
}
}
public void add(E e) {
int i = cursor;
synchronized (Vector.this) {
checkForComodification();
Vector.this.add(i, e);
expectedModCount = modCount;
}
cursor = i + 1;
lastRet = -1;
}
}一堆代码以及包含了两个内部实现类一个是Itr 正向迭代器，只能够向下查询。ListItr 双向迭代器。通过两个类似指针的标志位来进行数据的查询以及修改。
以上就是关于Vector的全部核心和有趣的方法。欢迎大家指正批评。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
