JDK源码分析——Java.util.Vector的浅析
来源:互联网 发布:java字符串与空拼接 编辑:程序博客网 时间:2024/06/04 19:38
首先我们来看JDK源码中Java.util.Vector的代码,剔除所有的方法和静态变量,
Java.lang.Vector的核心代码如下:
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ protected Object[] elementData; /** * The number of valid components in this {@code Vector} object. * Components {@code elementData[0]} through * {@code elementData[elementCount-1]} are the actual items. * * @serial */ protected int elementCount; protected int capacityIncrement; //可以设定固定增量}
通过上面的代码我们能看到他是数组存储。
它的构造方法有四个:
/** * Constructs an empty vector with the specified initial capacity and * capacity increment. * * @param initialCapacity the initial capacity of the vector * @param capacityIncrement the amount by which the capacity is * increased when the vector overflows * @throws IllegalArgumentException if the specified initial capacity * is negative */ public Vector(int initialCapacity, int capacityIncrement) { //设置初始容量,及固定增量super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);this.elementData = new Object[initialCapacity];this.capacityIncrement = capacityIncrement; } /** * Constructs an empty vector with the specified initial capacity and * with its capacity increment equal to zero. * * @param initialCapacity the initial capacity of the vector * @throws IllegalArgumentException if the specified initial capacity * is negative */ public Vector(int initialCapacity) { //设置初始容量,不设定固定增量(如果不设定固定增量,则成倍增长)this(initialCapacity, 0); } /** * Constructs an empty vector so that its internal data array * has size {@code 10} and its standard capacity increment is * zero. */ public Vector() { //不设置初始容量,初始容量为10,不设定固定增量(如果不设定固定增量,则成倍增长)this(10); } /** * Constructs a vector containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param c the collection whose elements are to be placed into this * vector * @throws NullPointerException if the specified collection is null * @since 1.2 */ 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类的 add(E e)方法的源代码:
/** * Appends the specified element to the end of this Vector. * * @param e element to be appended to this Vector * @return {@code true} (as specified by {@link Collection#add}) * @since 1.2 */ public synchronized boolean add(E e) { //从这里的synchronized我们可以知道他是线程同步的modCount++;ensureCapacityHelper(elementCount + 1); //是否需要扩容elementData[elementCount++] = e; //后放的永远在最后一位 return true; // 好像他永远返回true 哦 }
/** * This implements the unsynchronized semantics of ensureCapacity. * Synchronized methods in this class can internally call this * method for ensuring capacity without incurring the cost of an * extra synchronization. * * @see #ensureCapacity(int) */ private void ensureCapacityHelper(int minCapacity) {int oldCapacity = elementData.length;if (minCapacity > oldCapacity) { //最新的值如果超出现有容量 扩容 Object[] oldData = elementData; int newCapacity = (capacityIncrement > 0) ?(oldCapacity + capacityIncrement) : (oldCapacity * 2); //如果固定增量不为0则增长固定增量,否则成倍增长 if (newCapacity < minCapacity) { //新容量还小,这个可能性应该不大newCapacity = minCapacity; } elementData = Arrays.copyOf(elementData, newCapacity); // 改变数组的大小,这个方法可以记一下} }
下面我们再看一下 Vector类的 remove(Object o)方法的源代码:
/** * Removes the first occurrence of the specified element in this Vector * If the Vector does not contain the element, it is unchanged. More * formally, removes the element with the lowest index i such that * {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such * an element exists). * * @param o element to be removed from this Vector, if present * @return true if the Vector contained the specified element * @since 1.2 */ public boolean remove(Object o) { return removeElement(o); //他是调用的removeElement } /** * Removes the first (lowest-indexed) occurrence of the argument * from this vector. If the object is found in this vector, each * component in the vector with an index greater or equal to the * object's index is shifted downward to have an index one smaller * than the value it had previously. * * <p>This method is identical in functionality to the * {@link #remove(Object)} method (which is part of the * {@link List} interface). * * @param obj the component to be removed * @return {@code true} if the argument was a component of this * vector; {@code false} otherwise. */ public synchronized boolean removeElement(Object obj) {modCount++;int i = indexOf(obj); //查找obj第一次出现的位置,(Vector是允许重复值的)if (i >= 0) { removeElementAt(i); return true;}return false; } /** * Deletes the component at the specified index. Each component in * this vector with an index greater or equal to the specified * {@code index} is shifted downward to have an index one * smaller than the value it had previously. The size of this vector * is decreased by {@code 1}. * * <p>The index must be a value greater than or equal to {@code 0} * and less than the current size of the vector. * * <p>This method is identical in functionality to the {@link #remove(int)} * method (which is part of the {@link List} interface). Note that the * {@code remove} method returns the old value that was stored at the * specified position. * * @param index the index of the object to remove * @throws ArrayIndexOutOfBoundsException if the index is out of range * ({@code index < 0 || index >= size()}) */ 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; // 数组中index以后的元素个数if (j > 0) { System.arraycopy(elementData, index + 1, elementData, index, j); // 数组中index以后的元素,整体前移,(这个方法挺有用的!!)}elementCount--;elementData[elementCount] = null; /* to let gc do its work */ }
从上面的代码我们可以看出 Vector每次只删除最靠前的那个相符的变量。
下面我们再看一下 Vector类的 equals(Object o)方法的源代码:
/** * Compares the specified Object with this Vector for equality. Returns * true if and only if the specified Object is also a List, both Lists * have the same size, and all corresponding pairs of elements in the two * Lists are <em>equal</em>. (Two elements {@code e1} and * {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null : * e1.equals(e2))}.) In other words, two Lists are defined to be * equal if they contain the same elements in the same order. * * @param o the Object to be compared for equality with this Vector * @return true if the specified Object is equal to this Vector */ public synchronized boolean equals(Object o) { return super.equals(o); //他是调用的父类AbstractList的equals } /** * Compares the specified object with this list for equality. Returns * {@code true} if and only if the specified object is also a list, both * lists have the same size, and all corresponding pairs of elements in * the two lists are <i>equal</i>. (Two elements {@code e1} and * {@code e2} are <i>equal</i> if {@code (e1==null ? e2==null : * e1.equals(e2))}.) In other words, two lists are defined to be * equal if they contain the same elements in the same order.<p> * * This implementation first checks if the specified object is this * list. If so, it returns {@code true}; if not, it checks if the * specified object is a list. If not, it returns {@code false}; if so, * it iterates over both lists, comparing corresponding pairs of elements. * If any comparison returns {@code false}, this method returns * {@code false}. If either iterator runs out of elements before the * other it returns {@code false} (as the lists are of unequal length); * otherwise it returns {@code true} when the iterations complete. * * @param o the object to be compared for equality with this list * @return {@code true} if the specified object is equal to this list */ public boolean equals(Object o) {if (o == this) return true;if (!(o instanceof List)) return false;ListIterator<E> e1 = listIterator();ListIterator e2 = ((List) o).listIterator();while(e1.hasNext() && e2.hasNext()) { E o1 = e1.next(); Object o2 = e2.next(); if (!(o1==null ? o2==null : o1.equals(o2))) //判断了三次 //这个方法挺不错的,应该比if(!(null==o1&&null==o2)||(null!=o1&&o1.equals(o2)))(大于等于三次判断)return false;}return !(e1.hasNext() || e2.hasNext()); //长度是否一致 }
下面我们再看一下 Vector类的 hashCode()方法的源代码:
/** * Returns the hash code value for this Vector. */ public synchronized int hashCode() { return super.hashCode(); //他也是调用的父类AbstractList的hashCode }/** * Returns the hash code value for this list. * * <p>This implementation uses exactly the code that is used to define the * list hash function in the documentation for the {@link List#hashCode} * method. * * @return the hash code value for this list */ public int hashCode() {int hashCode = 1;Iterator<E> i = iterator();while (i.hasNext()) { E obj = i.next(); hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode()); // 在这里用obj,比用i.next()效率高一倍(一直没明白他这为什么用31)}return hashCode; }
- JDK源码分析——Java.util.Vector的浅析
- JDK源码分析——Java.util.Vector的浅析
- JDK源码——java.util
- JDK源码——java.util.concurrent
- JDK源码分析之java.util.ArrayList
- JDK源码分析(1)-java.util.ArrayList
- JDK源码分析(2)-java.util.LinkedList
- java util包学习(5) Vector 源码分析
- JDK源码——java.util.concurrent(二)
- JDK源码——java.util.concurrent(三)
- JDK源码——java.util.concurrent(四)
- JDK源码——java.util.concurrent(五)
- JDK源码——java.util.concurrent(六)
- JDK源码——java.util.concurrent(七)
- JDK源码——java.util.concurrent(八)
- JDK源码(FutureTask)——java.util.concurrent(十)
- JDK源码阅读 java.util.concurrent—并发容器类
- java.util.Vector源码解析
- 在网上找的一个Flex文件上传代码,记录下来,以后用到的时候可以马上能用:
- Maven3 Linux(Ubuntu) 安装
- ++i与i++
- 搜索框按回车 刷新了页面
- Javascript在页面加载时的执行顺序
- JDK源码分析——Java.util.Vector的浅析
- WinCVS 宏不可用的解决方案
- OpenGL函数思考-glTexCoord
- HALCON形状匹配(转)
- css学习笔记1
- 怎样在virtualbox下WIN7共XP的文件
- gfs(google file system)
- Windows7修改hosts提示:您没有权限在此位置中保存文件
- jdk1.4 jdk1.5 jdk1.6 jdk1.7