--- jsr166/src/main/java/util/Vector.java 2006/05/28 23:36:29 1.13
+++ jsr166/src/main/java/util/Vector.java 2006/06/26 00:31:07 1.19
@@ -8,18 +8,18 @@
package java.util;
/**
- * The Vector
class implements a growable array of
+ * The {@code Vector} class implements a growable array of
* objects. Like an array, it contains components that can be
* accessed using an integer index. However, the size of a
- * Vector
can grow or shrink as needed to accommodate
- * adding and removing items after the Vector
has been created.
+ * {@code Vector} can grow or shrink as needed to accommodate
+ * adding and removing items after the {@code Vector} has been created.
*
*
Each vector tries to optimize storage management by maintaining a
- * capacity
and a capacityIncrement
. The
- * capacity
is always at least as large as the vector
+ * {@code capacity} and a {@code capacityIncrement}. The
+ * {@code capacity} is always at least as large as the vector
* size; it is usually larger because as components are added to the
* vector, the vector's storage increases in chunks the size of
- * capacityIncrement
. An application can increase the
+ * {@code capacityIncrement}. An application can increase the
* capacity of a vector before inserting a large number of
* components; this reduces the amount of incremental reallocation.
*
@@ -36,7 +36,7 @@ package java.util;
*
Note that the fail-fast behavior of an iterator cannot be guaranteed
* as it is, generally speaking, impossible to make any hard guarantees in the
* presence of unsynchronized concurrent modification. Fail-fast iterators
- * throw ConcurrentModificationException on a best-effort basis.
+ * throw {@code ConcurrentModificationException} on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: the fail-fast behavior of iterators
* should be used only to detect bugs.
@@ -63,18 +63,18 @@ public class Vector
+ * and is at least large enough to contain all the vector's elements.
*
- * Any array elements following the last element in the Vector are null.
+ * Any array elements following the last element in the Vector are null.
*
* @serial
*/
protected Object[] elementData;
/**
- * The number of valid components in this Vector object.
- * Components elementData[0] through
- * elementData[elementCount-1] are the actual items.
+ * The number of valid components in this {@code Vector} object.
+ * Components {@code elementData[0]} through
+ * {@code elementData[elementCount-1]} are the actual items.
*
* @serial
*/
@@ -100,8 +100,8 @@ public class Vector If the current capacity of this vector is less than
- * minCapacity, then its capacity is increased by replacing its
- * internal data array, kept in the field elementData, with a
+ * {@code minCapacity}, then its capacity is increased by replacing its
+ * internal data array, kept in the field {@code elementData}, with a
* larger one. The size of the new data array will be the old size plus
- * capacityIncrement, unless the value of
- * capacityIncrement is less than or equal to zero, in which case
+ * {@code capacityIncrement}, unless the value of
+ * {@code capacityIncrement} is less than or equal to zero, in which case
* the new capacity will be twice the old capacity; but if this new size
- * is still smaller than minCapacity, then the new capacity will
- * be minCapacity.
+ * is still smaller than {@code minCapacity}, then the new capacity will
+ * be {@code minCapacity}.
*
* @param minCapacity the desired minimum capacity
*/
@@ -212,7 +212,7 @@ public class Vector
+ * Returns the component at the specified index.
*
- * This method is identical in functionality to the get method
- * (which is part of the List interface).
+ * This method is identical in functionality to the {@link #get(int)}
+ * method (which is part of the {@link List} interface).
*
* @param index an index into this vector
* @return the component at the specified index
- * @exception ArrayIndexOutOfBoundsException if the index
- * is negative or not less than the current size of this
- * Vector object.
- * @see #get(int)
- * @see List
+ * @throws ArrayIndexOutOfBoundsException if the index is out of range
+ * ({@code index < 0 || index >= size()})
*/
public synchronized E elementAt(int index) {
if (index >= elementCount) {
@@ -435,11 +431,11 @@ public class Vector
+ * position is discarded.
*
- * The index must be a value greater than or equal to
+ * The index must be a value greater than or equal to {@code 0}
+ * and less than the current size of the vector.
*
- * This method is identical in functionality to the set method
- * (which is part of the List interface). Note that the set method reverses
- * the order of the parameters, to more closely match array usage. Note
- * also that the set method returns the old value that was stored at the
- * specified position.
+ * This method is identical in functionality to the
+ * {@link #set(int, Object) set(int, E)}
+ * method (which is part of the {@link List} interface). Note that the
+ * {@code set} method reverses the order of the parameters, to more closely
+ * match array usage. Note also that the {@code set} method returns the
+ * old value that was stored at the specified position.
*
* @param obj what the component is to be set to
* @param index the specified index
- * @exception ArrayIndexOutOfBoundsException if the index was invalid
- * @see #size()
- * @see List
- * @see #set(int, java.lang.Object)
+ * @throws ArrayIndexOutOfBoundsException if the index is out of range
+ * ({@code index < 0 || index >= size()})
*/
public synchronized void setElementAt(E obj, int index) {
if (index >= elementCount) {
@@ -494,22 +489,21 @@ public class Vector
+ * is decreased by {@code 1}.
*
- * The index must be a value greater than or equal to
+ * The index must be a value greater than or equal to {@code 0}
+ * and less than the current size of the vector.
*
- * This method is identical in functionality to the remove method
- * (which is part of the List interface). Note that the remove method
- * returns the old value that was stored at the specified position.
+ * 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
- * @exception ArrayIndexOutOfBoundsException if the index was invalid
- * @see #size()
- * @see #remove(int)
- * @see List
+ * @throws ArrayIndexOutOfBoundsException if the index is out of range
+ * ({@code index < 0 || index >= size()})
*/
public synchronized void removeElementAt(int index) {
modCount++;
@@ -530,26 +524,26 @@ public class Vector
+ * previously.
*
- * The index must be a value greater than or equal to The index must be a value greater than or equal to {@code 0}
* and less than or equal to the current size of the vector. (If the
* index is equal to the current size of the vector, the new element
- * is appended to the Vector.)
+ * is appended to the Vector.)
*
- * This method is identical in functionality to the add(Object, int) method
- * (which is part of the List interface). Note that the add method reverses
- * the order of the parameters, to more closely match array usage.
+ * This method is identical in functionality to the
+ * {@link #add(int, Object) add(int, E)}
+ * method (which is part of the {@link List} interface). Note that the
+ * {@code add} method reverses the order of the parameters, to more closely
+ * match array usage.
*
* @param obj the component to insert
* @param index where to insert the new component
- * @exception ArrayIndexOutOfBoundsException if the index was invalid
- * @see #size()
- * @see #add(int, Object)
- * @see List
+ * @throws ArrayIndexOutOfBoundsException if the index is out of range
+ * ({@code index < 0 || index > size()})
*/
public synchronized void insertElementAt(E obj, int index) {
modCount++;
@@ -566,14 +560,13 @@ public class Vector
+ * increased if its size becomes greater than its capacity.
*
- * This method is identical in functionality to the add(Object) method
- * (which is part of the List interface).
+ * This method is identical in functionality to the
+ * {@link #add(Object) add(E)}
+ * method (which is part of the {@link List} interface).
*
* @param obj the component to be added
- * @see #add(Object)
- * @see List
*/
public synchronized void addElement(E obj) {
modCount++;
@@ -586,16 +579,15 @@ public class Vector
+ * than the value it had previously.
*
- * This method is identical in functionality to the remove(Object)
- * method (which is part of the List interface).
+ * 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
- *
- * This method is identical in functionality to the clear method
- * (which is part of the List interface).
+ * Removes all components from this vector and sets its size to zero.
*
- * @see #clear
- * @see List
+ * This method is identical in functionality to the {@link #clear}
+ * method (which is part of the {@link List} interface).
*/
public synchronized void removeAllElements() {
modCount++;
@@ -628,7 +617,7 @@ public class Vector
+ * type of the specified array and the size of this Vector.
*
- * If the Vector fits in the specified array with room to spare
+ * If the Vector fits in the specified array with room to spare
* (i.e., the array has more elements than the Vector),
* the element in the array immediately following the end of the
* Vector is set to null. (This is useful in determining the length
@@ -672,7 +661,7 @@ public class Vector
+ * operations supported by this List.
*
- * This method eliminates the need for explicit range operations (of
+ * This method eliminates the need for explicit range operations (of
* the sort that commonly exist for arrays). Any operation that expects
* a List can be used as a range operation by operating on a subList view
* instead of a whole List. For example, the following idiom
@@ -1161,9 +1150,9 @@ public class Vector
+ * a subList.
*
- * The semantics of the List returned by this method become undefined if
+ * The semantics of the List returned by this method become undefined if
* the backing list (i.e., this List) is structurally modified in
* any way other than via the returned List. (Structural modifications are
* those that change the size of the List, or otherwise perturb it in such
@@ -1172,10 +1161,10 @@ public class Vectornull
items are added to the end of
+ * current size, new {@code null} items are added to the end of
* the vector. If the new size is less than the current size, all
- * components at index newSize
and greater are discarded.
+ * components at index {@code newSize} and greater are discarded.
*
- * @param newSize the new size of this vector
- * @throws ArrayIndexOutOfBoundsException if new size is negative
+ * @param newSize the new size of this vector
+ * @throws ArrayIndexOutOfBoundsException if the new size is negative
*/
public synchronized void setSize(int newSize) {
modCount++;
@@ -252,7 +252,7 @@ public class Vectortrue
if and only if this vector has
+ * @return {@code true} if and only if this vector has
* no components, that is, its size is zero;
- * false
otherwise.
+ * {@code false} otherwise.
*/
public synchronized boolean isEmpty() {
return elementCount == 0;
@@ -281,12 +281,11 @@ public class Vectorsize() - 1
.
- * @exception NoSuchElementException if this vector is empty
+ * @throws NoSuchElementException if this vector is empty
*/
public synchronized E lastElement() {
if (elementCount == 0) {
@@ -463,25 +459,24 @@ public class Vectorindex
of this
+ * Sets the component at the specified {@code index} of this
* vector to be the specified object. The previous component at that
- * position is discarded.0
- * and less than the current size of the vector. index
is shifted downward to have an index one
+ * {@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 1.0
- * and less than the current size of the vector. index
. Each component in this vector with
- * an index greater or equal to the specified index
is
+ * specified {@code index}. Each component in this vector with
+ * an index greater or equal to the specified {@code index} is
* shifted upward to have an index one greater than the value it had
- * previously. 0
+ * true
if the argument was a component of this
- * vector; false
otherwise.
- * @see List#remove(Object)
- * @see List
+ * @return {@code true} if the argument was a component of this
+ * vector; {@code false} otherwise.
*/
public synchronized boolean removeElement(Object obj) {
modCount++;
@@ -608,13 +600,10 @@ public class Vector(o==null ? get(i)==null : o.equals(get(i)))
(if such
+ * {@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
@@ -763,8 +752,8 @@ public class Vectore1
and
- * e2
are equal if (e1==null ? e2==null :
- * e1.equals(e2))
.) In other words, two Lists are defined to be
+ * Lists are equal. (Two elements {@code e1} and
+ * {@code e2} are equal 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
@@ -974,7 +963,7 @@ public class Vector(fromIndex < 0 || toIndex > size)
- * @throws IllegalArgumentException endpoint indices out of order
- * (fromIndex > toIndex)
+ * @throws IndexOutOfBoundsException if an endpoint index value is out of range
+ * {@code (fromIndex < 0 || toIndex > size)}
+ * @throws IllegalArgumentException if the endpoint indices are out of order
+ * {@code (fromIndex > toIndex)}
*/
public synchronized List