ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/Vector.java
(Generate patch)

Comparing jsr166/src/main/java/util/Vector.java (file contents):
Revision 1.10 by dl, Wed Apr 19 15:07:14 2006 UTC vs.
Revision 1.14 by jsr166, Sun Jun 25 19:41:52 2006 UTC

# Line 1 | Line 1
1   /*
2 < * @(#)Vector.java      1.103 05/12/06
2 > * %W% %E%
3   *
4   * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
5   * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
# Line 8 | Line 8
8   package java.util;
9  
10   /**
11 < * The <code>Vector</code> class implements a growable array of
11 > * The {@code Vector} class implements a growable array of
12   * objects. Like an array, it contains components that can be
13   * accessed using an integer index. However, the size of a
14 < * <code>Vector</code> can grow or shrink as needed to accommodate
15 < * adding and removing items after the <code>Vector</code> has been created.
14 > * {@code Vector} can grow or shrink as needed to accommodate
15 > * adding and removing items after the {@code Vector} has been created.
16   *
17   * <p>Each vector tries to optimize storage management by maintaining a
18 < * <code>capacity</code> and a <code>capacityIncrement</code>. The
19 < * <code>capacity</code> is always at least as large as the vector
18 > * {@code capacity} and a {@code capacityIncrement}. The
19 > * {@code capacity} is always at least as large as the vector
20   * size; it is usually larger because as components are added to the
21   * vector, the vector's storage increases in chunks the size of
22 < * <code>capacityIncrement</code>. An application can increase the
22 > * {@code capacityIncrement}. An application can increase the
23   * capacity of a vector before inserting a large number of
24   * components; this reduces the amount of incremental reallocation.
25   *
# Line 36 | Line 36 | package java.util;
36   * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
37   * as it is, generally speaking, impossible to make any hard guarantees in the
38   * presence of unsynchronized concurrent modification.  Fail-fast iterators
39 < * throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
39 > * throw {@code ConcurrentModificationException} on a best-effort basis.
40   * Therefore, it would be wrong to write a program that depended on this
41   * exception for its correctness:  <i>the fail-fast behavior of iterators
42   * should be used only to detect bugs.</i>
43   *
44   * <p>As of the Java 2 platform v1.2, this class was retrofitted to
45   * implement the {@link List} interface, making it a member of the
46 < * <a href="{@docRoot}/../guide/collections/index.html"> Java
46 > * <a href="{@docRoot}/../technotes/guides/collections/index.html"> Java
47   * Collections Framework</a>.  Unlike the new collection
48   * implementations, {@code Vector} is synchronized.
49   *
50   * @author  Lee Boynton
51   * @author  Jonathan Payne
52 < * @version 1.103, 12/06/05
52 > * @version %I%, %G%
53   * @see Collection
54   * @see List
55   * @see ArrayList
# Line 72 | Line 72 | public class Vector<E>
72      protected Object[] elementData;
73  
74      /**
75 <     * The number of valid components in this <tt>Vector</tt> object.
76 <     * Components <tt>elementData[0]</tt> through
77 <     * <tt>elementData[elementCount-1]</tt> are the actual items.
75 >     * The number of valid components in this {@code Vector} object.
76 >     * Components {@code elementData[0]} through
77 >     * {@code elementData[elementCount-1]} are the actual items.
78       *
79       * @serial
80       */
# Line 126 | Line 126 | public class Vector<E>
126  
127      /**
128       * Constructs an empty vector so that its internal data array
129 <     * has size <tt>10</tt> and its standard capacity increment is
129 >     * has size {@code 10} and its standard capacity increment is
130       * zero.
131       */
132      public Vector() {
# Line 153 | Line 153 | public class Vector<E>
153  
154      /**
155       * Copies the components of this vector into the specified array.
156 <     * The item at index <tt>k</tt> in this vector is copied into
157 <     * component <tt>k</tt> of <tt>anArray</tt>.
156 >     * The item at index {@code k} in this vector is copied into
157 >     * component {@code k} of {@code anArray}.
158       *
159       * @param  anArray the array into which the components get copied
160       * @throws NullPointerException if the given array is null
# Line 172 | Line 172 | public class Vector<E>
172       * Trims the capacity of this vector to be the vector's current
173       * size. If the capacity of this vector is larger than its current
174       * size, then the capacity is changed to equal the size by replacing
175 <     * its internal data array, kept in the field <tt>elementData</tt>,
175 >     * its internal data array, kept in the field {@code elementData},
176       * with a smaller one. An application can use this operation to
177       * minimize the storage of a vector.
178       */
# Line 190 | Line 190 | public class Vector<E>
190       * the minimum capacity argument.
191       *
192       * <p>If the current capacity of this vector is less than
193 <     * <tt>minCapacity</tt>, then its capacity is increased by replacing its
194 <     * internal data array, kept in the field <tt>elementData</tt>, with a
193 >     * {@code minCapacity}, then its capacity is increased by replacing its
194 >     * internal data array, kept in the field {@code elementData}, with a
195       * larger one.  The size of the new data array will be the old size plus
196 <     * <tt>capacityIncrement</tt>, unless the value of
197 <     * <tt>capacityIncrement</tt> is less than or equal to zero, in which case
196 >     * {@code capacityIncrement}, unless the value of
197 >     * {@code capacityIncrement} is less than or equal to zero, in which case
198       * the new capacity will be twice the old capacity; but if this new size
199 <     * is still smaller than <tt>minCapacity</tt>, then the new capacity will
200 <     * be <tt>minCapacity</tt>.
199 >     * is still smaller than {@code minCapacity}, then the new capacity will
200 >     * be {@code minCapacity}.
201       *
202       * @param minCapacity the desired minimum capacity
203       */
# Line 229 | Line 229 | public class Vector<E>
229  
230      /**
231       * Sets the size of this vector. If the new size is greater than the
232 <     * current size, new <code>null</code> items are added to the end of
232 >     * current size, new {@code null} items are added to the end of
233       * the vector. If the new size is less than the current size, all
234 <     * components at index <code>newSize</code> and greater are discarded.
234 >     * components at index {@code newSize} and greater are discarded.
235       *
236       * @param   newSize   the new size of this vector
237       * @throws  ArrayIndexOutOfBoundsException if new size is negative
# Line 252 | Line 252 | public class Vector<E>
252       * Returns the current capacity of this vector.
253       *
254       * @return  the current capacity (the length of its internal
255 <     *          data array, kept in the field <tt>elementData</tt>
255 >     *          data array, kept in the field {@code elementData}
256       *          of this vector)
257       */
258      public synchronized int capacity() {
# Line 271 | Line 271 | public class Vector<E>
271      /**
272       * Tests if this vector has no components.
273       *
274 <     * @return  <code>true</code> if and only if this vector has
274 >     * @return  {@code true} if and only if this vector has
275       *          no components, that is, its size is zero;
276 <     *          <code>false</code> otherwise.
276 >     *          {@code false} otherwise.
277       */
278      public synchronized boolean isEmpty() {
279          return elementCount == 0;
# Line 281 | Line 281 | public class Vector<E>
281  
282      /**
283       * Returns an enumeration of the components of this vector. The
284 <     * returned <tt>Enumeration</tt> object will generate all items in
285 <     * this vector. The first item generated is the item at index <tt>0</tt>,
286 <     * then the item at index <tt>1</tt>, and so on.
284 >     * returned {@code Enumeration} object will generate all items in
285 >     * this vector. The first item generated is the item at index {@code 0},
286 >     * then the item at index {@code 1}, and so on.
287       *
288       * @return  an enumeration of the components of this vector
289       * @see     Enumeration
# Line 309 | Line 309 | public class Vector<E>
309      }
310  
311      /**
312 <     * Returns <tt>true</tt> if this vector contains the specified element.
313 <     * More formally, returns <tt>true</tt> if and only if this vector
314 <     * contains at least one element <tt>e</tt> such that
312 >     * Returns {@code true} if this vector contains the specified element.
313 >     * More formally, returns {@code true} if and only if this vector
314 >     * contains at least one element {@code e} such that
315       * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
316       *
317       * @param o element whose presence in this vector is to be tested
318 <     * @return <tt>true</tt> if this vector contains the specified element
318 >     * @return {@code true} if this vector contains the specified element
319       */
320      public boolean contains(Object o) {
321          return indexOf(o, 0) >= 0;
# Line 324 | Line 324 | public class Vector<E>
324      /**
325       * Returns the index of the first occurrence of the specified element
326       * in this vector, or -1 if this vector does not contain the element.
327 <     * More formally, returns the lowest index <tt>i</tt> such that
327 >     * More formally, returns the lowest index {@code i} such that
328       * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
329       * or -1 if there is no such index.
330       *
# Line 338 | Line 338 | public class Vector<E>
338  
339      /**
340       * Returns the index of the first occurrence of the specified element in
341 <     * this vector, searching forwards from <tt>index</tt>, or returns -1 if
341 >     * this vector, searching forwards from {@code index}, or returns -1 if
342       * the element is not found.
343 <     * More formally, returns the lowest index <tt>i</tt> such that
343 >     * More formally, returns the lowest index {@code i} such that
344       * <tt>(i&nbsp;&gt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
345       * or -1 if there is no such index.
346       *
347       * @param o element to search for
348       * @param index index to start searching from
349       * @return the index of the first occurrence of the element in
350 <     *         this vector at position <tt>index</tt> or later in the vector;
351 <     *         <tt>-1</tt> if the element is not found.
350 >     *         this vector at position {@code index} or later in the vector;
351 >     *         {@code -1} if the element is not found.
352       * @throws IndexOutOfBoundsException if the specified index is negative
353       * @see     Object#equals(Object)
354       */
# Line 368 | Line 368 | public class Vector<E>
368      /**
369       * Returns the index of the last occurrence of the specified element
370       * in this vector, or -1 if this vector does not contain the element.
371 <     * More formally, returns the highest index <tt>i</tt> such that
371 >     * More formally, returns the highest index {@code i} such that
372       * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
373       * or -1 if there is no such index.
374       *
# Line 382 | Line 382 | public class Vector<E>
382  
383      /**
384       * Returns the index of the last occurrence of the specified element in
385 <     * this vector, searching backwards from <tt>index</tt>, or returns -1 if
385 >     * this vector, searching backwards from {@code index}, or returns -1 if
386       * the element is not found.
387 <     * More formally, returns the highest index <tt>i</tt> such that
387 >     * More formally, returns the highest index {@code i} such that
388       * <tt>(i&nbsp;&lt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
389       * or -1 if there is no such index.
390       *
391       * @param o element to search for
392       * @param index index to start searching backwards from
393       * @return the index of the last occurrence of the element at position
394 <     *         less than or equal to <tt>index</tt> in this vector;
394 >     *         less than or equal to {@code index} in this vector;
395       *         -1 if the element is not found.
396       * @throws IndexOutOfBoundsException if the specified index is greater
397       *         than or equal to the current size of this vector
# Line 420 | Line 420 | public class Vector<E>
420       *
421       * @param      index   an index into this vector
422       * @return     the component at the specified index
423 <     * @exception  ArrayIndexOutOfBoundsException  if the <tt>index</tt>
423 >     * @exception  ArrayIndexOutOfBoundsException  if the {@code index}
424       *             is negative or not less than the current size of this
425 <     *             <tt>Vector</tt> object.
425 >     *             {@code Vector} object.
426       * @see        #get(int)
427       * @see        List
428       */
# Line 435 | Line 435 | public class Vector<E>
435      }
436  
437      /**
438 <     * Returns the first component (the item at index <tt>0</tt>) of
438 >     * Returns the first component (the item at index {@code 0}) of
439       * this vector.
440       *
441       * @return     the first component of this vector
# Line 463 | Line 463 | public class Vector<E>
463      }
464  
465      /**
466 <     * Sets the component at the specified <code>index</code> of this
466 >     * Sets the component at the specified {@code index} of this
467       * vector to be the specified object. The previous component at that
468       * position is discarded.<p>
469       *
470 <     * The index must be a value greater than or equal to <code>0</code>
470 >     * The index must be a value greater than or equal to {@code 0}
471       * and less than the current size of the vector. <p>
472       *
473       * This method is identical in functionality to the set method
# Line 494 | Line 494 | public class Vector<E>
494      /**
495       * Deletes the component at the specified index. Each component in
496       * this vector with an index greater or equal to the specified
497 <     * <code>index</code> is shifted downward to have an index one
497 >     * {@code index} is shifted downward to have an index one
498       * smaller than the value it had previously. The size of this vector
499 <     * is decreased by <tt>1</tt>.<p>
499 >     * is decreased by {@code 1}.<p>
500       *
501 <     * The index must be a value greater than or equal to <code>0</code>
501 >     * The index must be a value greater than or equal to {@code 0}
502       * and less than the current size of the vector. <p>
503       *
504       * This method is identical in functionality to the remove method
# Line 530 | Line 530 | public class Vector<E>
530  
531      /**
532       * Inserts the specified object as a component in this vector at the
533 <     * specified <code>index</code>. Each component in this vector with
534 <     * an index greater or equal to the specified <code>index</code> is
533 >     * specified {@code index}. Each component in this vector with
534 >     * an index greater or equal to the specified {@code index} is
535       * shifted upward to have an index one greater than the value it had
536       * previously. <p>
537       *
538 <     * The index must be a value greater than or equal to <code>0</code>
538 >     * The index must be a value greater than or equal to {@code 0}
539       * and less than or equal to the current size of the vector. (If the
540       * index is equal to the current size of the vector, the new element
541       * is appended to the Vector.)<p>
# Line 592 | Line 592 | public class Vector<E>
592       * method (which is part of the List interface).
593       *
594       * @param   obj   the component to be removed
595 <     * @return  <code>true</code> if the argument was a component of this
596 <     *          vector; <code>false</code> otherwise.
595 >     * @return  {@code true} if the argument was a component of this
596 >     *          vector; {@code false} otherwise.
597       * @see     List#remove(Object)
598       * @see     List
599       */
# Line 628 | Line 628 | public class Vector<E>
628      /**
629       * Returns a clone of this vector. The copy will contain a
630       * reference to a clone of the internal data array, not a reference
631 <     * to the original internal data array of this <tt>Vector</tt> object.
631 >     * to the original internal data array of this {@code Vector} object.
632       *
633       * @return  a clone of this vector
634       */
# Line 731 | Line 731 | public class Vector<E>
731       * Appends the specified element to the end of this Vector.
732       *
733       * @param e element to be appended to this Vector
734 <     * @return <tt>true</tt> (as specified by {@link Collection#add})
734 >     * @return {@code true} (as specified by {@link Collection#add})
735       * @since 1.2
736       */
737      public synchronized boolean add(E e) {
# Line 745 | Line 745 | public class Vector<E>
745       * Removes the first occurrence of the specified element in this Vector
746       * If the Vector does not contain the element, it is unchanged.  More
747       * formally, removes the element with the lowest index i such that
748 <     * <code>(o==null ? get(i)==null : o.equals(get(i)))</code> (if such
748 >     * {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
749       * an element exists).
750       *
751       * @param o element to be removed from this Vector, if present
# Line 832 | Line 832 | public class Vector<E>
832       * specified Collection is this Vector, and this Vector is nonempty.)
833       *
834       * @param c elements to be inserted into this Vector
835 <     * @return <tt>true</tt> if this Vector changed as a result of the call
835 >     * @return {@code true} if this Vector changed as a result of the call
836       * @throws NullPointerException if the specified collection is null
837       * @since 1.2
838       */
# Line 895 | Line 895 | public class Vector<E>
895       * @param index index at which to insert the first element from the
896       *              specified collection
897       * @param c elements to be inserted into this Vector
898 <     * @return <tt>true</tt> if this Vector changed as a result of the call
898 >     * @return {@code true} if this Vector changed as a result of the call
899       * @exception ArrayIndexOutOfBoundsException index out of range (index
900       *            &lt; 0 || index &gt; size())
901       * @throws NullPointerException if the specified collection is null
# Line 924 | Line 924 | public class Vector<E>
924       * Compares the specified Object with this Vector for equality.  Returns
925       * true if and only if the specified Object is also a List, both Lists
926       * have the same size, and all corresponding pairs of elements in the two
927 <     * Lists are <em>equal</em>.  (Two elements <code>e1</code> and
928 <     * <code>e2</code> are <em>equal</em> if <code>(e1==null ? e2==null :
929 <     * e1.equals(e2))</code>.)  In other words, two Lists are defined to be
927 >     * Lists are <em>equal</em>.  (Two elements {@code e1} and
928 >     * {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
929 >     * e1.equals(e2))}.)  In other words, two Lists are defined to be
930       * equal if they contain the same elements in the same order.
931       *
932       * @param o the Object to be compared for equality with this Vector
# Line 974 | Line 974 | public class Vector<E>
974      }
975  
976      /**
977 <     * Save the state of the <tt>Vector</tt> instance to a stream (that
977 >     * Save the state of the {@code Vector} instance to a stream (that
978       * is, serialize it).  This method is present merely for synchronization.
979       * It just calls the default writeObject method.
980       */
# Line 1194 | Line 1194 | public class Vector<E>
1194          final int parentOffset;           // index wrt parent
1195          int length;                       // length of sublist
1196  
1197 <        VectorSubList(Vector<E> base, AbstractList<E> parent, int baseOffset,
1197 >        VectorSubList(Vector<E> base, AbstractList<E> parent, int baseOffset,
1198                       int fromIndex, int toIndex) {
1199              if (fromIndex < 0)
1200                  throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
# Line 1216 | Line 1216 | public class Vector<E>
1216           * Returns an IndexOutOfBoundsException with nicer message
1217           */
1218          private IndexOutOfBoundsException indexError(int index) {
1219 <            return new IndexOutOfBoundsException("Index: " + index +
1219 >            return new IndexOutOfBoundsException("Index: " + index +
1220                                                   ", Size: " + length);
1221          }
1222  
# Line 1277 | Line 1277 | public class Vector<E>
1277              synchronized(base) {
1278                  if (base.modCount != modCount)
1279                      throw new ConcurrentModificationException();
1280 <                parent.removeRange(fromIndex + parentOffset,
1280 >                parent.removeRange(fromIndex + parentOffset,
1281                                     toIndex + parentOffset);
1282                  length -= (toIndex-fromIndex);
1283                  modCount = base.modCount;
# Line 1295 | Line 1295 | public class Vector<E>
1295                  int cSize = c.size();
1296                  if (cSize==0)
1297                      return false;
1298 <                
1298 >
1299                  if (base.modCount != modCount)
1300                      throw new ConcurrentModificationException();
1301                  parent.addAll(parentOffset + index, c);
# Line 1322 | Line 1322 | public class Vector<E>
1322          }
1323  
1324          public List<E> subList(int fromIndex, int toIndex) {
1325 <            return new VectorSubList(base, this, fromIndex + baseOffset,
1325 >            return new VectorSubList(base, this, fromIndex + baseOffset,
1326                                       fromIndex, toIndex);
1327          }
1328  
# Line 1331 | Line 1331 | public class Vector<E>
1331                  return new VectorSubListIterator(this, 0);
1332              }
1333          }
1334 <        
1334 >
1335          public synchronized ListIterator<E> listIterator() {
1336              synchronized(base) {
1337                  return new VectorSubListIterator(this, 0);
# Line 1358 | Line 1358 | public class Vector<E>
1358              int fence;                    // Upper bound on cursor
1359              int lastRet;                  // Index of returned element, or -1
1360              int expectedModCount;         // Expected modCount of base Vector
1361 <        
1361 >
1362              VectorSubListIterator(VectorSubList<E> list, int index) {
1363                  this.lastRet = -1;
1364                  this.cursor = index;
# Line 1368 | Line 1368 | public class Vector<E>
1368                  this.base = list.base;
1369                  this.expectedModCount = base.modCount;
1370              }
1371 <        
1371 >
1372              public boolean hasNext() {
1373                  return cursor < fence;
1374              }
1375 <        
1375 >
1376              public boolean hasPrevious() {
1377                  return cursor > 0;
1378              }
1379 <        
1379 >
1380              public int nextIndex() {
1381                  return cursor;
1382              }
1383 <        
1383 >
1384              public int previousIndex() {
1385                  return cursor - 1;
1386              }
1387 <        
1387 >
1388              public E next() {
1389                  int i = cursor;
1390                  if (cursor >= fence)
# Line 1394 | Line 1394 | public class Vector<E>
1394                  cursor = i + 1;
1395                  return (E)next;
1396              }
1397 <        
1397 >
1398              public E previous() {
1399                  int i = cursor - 1;
1400                  if (i < 0)
# Line 1404 | Line 1404 | public class Vector<E>
1404                  cursor = i;
1405                  return (E)prev;
1406              }
1407 <        
1407 >
1408              public void set(E e) {
1409                  if (lastRet < 0)
1410                      throw new IllegalStateException();
# Line 1417 | Line 1417 | public class Vector<E>
1417                      throw new ConcurrentModificationException();
1418                  }
1419              }
1420 <        
1420 >
1421              public void remove() {
1422                  int i = lastRet;
1423                  if (i < 0)
# Line 1435 | Line 1435 | public class Vector<E>
1435                      throw new ConcurrentModificationException();
1436                  }
1437              }
1438 <        
1438 >
1439              public void add(E e) {
1440                  if (base.modCount != expectedModCount)
1441                      throw new ConcurrentModificationException();
# Line 1455 | Line 1455 | public class Vector<E>
1455   }
1456  
1457  
1458 <    
1458 >

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines