jdk-sandbox: comparison jdk/src/share/classes/java/util/Vector.java

equal deleted inserted replaced

-:2da866863b98
+:91f5e4399160
 * {@link ListIterator#add(Object) add} methods, the iterator will throw a
 * {@link ConcurrentModificationException}.  Thus, in the face of
 * concurrent modification, the iterator fails quickly and cleanly, rather
 * than risking arbitrary, non-deterministic behavior at an undetermined
 * time in the future.  The {@link Enumeration Enumerations} returned by
-* the {@link #elements() elements} method are <em>not</em> fail-fast.
+* the {@link #elements() elements} method are <em>not</em> fail-fast; if the
+* Vector is structurally modified at any time after the enumeration is
+* created then the results of enumerating are undefined.
 *
 * <p>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 {@code ConcurrentModificationException} on a best-effort basis.
 * Java Collections Framework</a>.  Unlike the new collection
 * implementations, {@code Vector} is synchronized.  If a thread-safe
 * implementation is not needed, it is recommended to use {@link
 * ArrayList} in place of {@code Vector}.
 *
+* @param <E> Type of component elements
+*
 * @author  Lee Boynton
 * @author  Jonathan Payne
 * @see Collection
 * @see LinkedList
 * @since   JDK1.0
 /**
 * Returns an enumeration of the components of this vector. The
 * returned {@code Enumeration} object will generate all items in
 * this vector. The first item generated is the item at index {@code 0},
-* then the item at index {@code 1}, and so on.
+* then the item at index {@code 1}, and so on. If the vector is
+* structurally modified while enumerating over the elements then the
+* results of enumerating are undefined.
 *
 * @return  an enumeration of the components of this vector
 * @see     Iterator
 */
 public Enumeration<E> elements() {
 * @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) {
 }
 int j = elementCount - index - 1;
 if (j > 0) {
 System.arraycopy(elementData, index + 1, elementData, index, j);
 }
+modCount++;
 elementCount--;
 elementData[elementCount] = null; /* to let gc do its work */
 }
 /**
 * @param      index   where to insert the new component
 * @throws ArrayIndexOutOfBoundsException if the index is out of range
 *         ({@code index < 0 || index > size()})
 */
 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;
+modCount++;
 elementCount++;
 }
 /**
 * Adds the specified component to the end of this vector,
 * method (which is part of the {@link List} interface).
 *
 * @param   obj   the component to be added
 */
 public synchronized void addElement(E obj) {
+ensureCapacityHelper(elementCount + 1);
 modCount++;
-ensureCapacityHelper(elementCount + 1);
 elementData[elementCount++] = obj;
 }
 /**
 * Removes the first (lowest-indexed) occurrence of the argument
 *
 * <p>This method is identical in functionality to the {@link #clear}
 * method (which is part of the {@link List} interface).
 */
 public synchronized void removeAllElements() {
-modCount++;
 // Let gc do its work
 for (int i = 0; i < elementCount; i++)
 elementData[i] = null;
+modCount++;
 elementCount = 0;
 }
 /**
 * Returns a clone of this vector. The copy will contain a
 * the element in the array immediately following the end of the
 * Vector is set to null.  (This is useful in determining the length
 * of the Vector <em>only</em> if the caller knows that the Vector
 * does not contain any null elements.)
 *
+* @param <T> type of array elements. The same type as {@code <E>} or a
+* supertype of {@code <E>}.
 * @param a the array into which the elements of the Vector are to
 *          be stored, if it is big enough; otherwise, a new array of the
 *          same runtime type is allocated for this purpose.
 * @return an array containing the elements of the Vector
-* @throws ArrayStoreException if the runtime type of a is not a supertype
+* @throws ArrayStoreException if the runtime type of a, {@code <T>}, is not
-* of the runtime type of every element in this Vector
+* a supertype of the runtime type, {@code <E>}, of every element in this
+* Vector
 * @throws NullPointerException if the given array is null
 * @since 1.2
 */
 @SuppressWarnings("unchecked")
 public synchronized <T> T[] toArray(T[] a) {
 * @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) {
+ensureCapacityHelper(elementCount + 1);
 modCount++;
-ensureCapacityHelper(elementCount + 1);
 elementData[elementCount++] = e;
 return true;
 }
 /**
 * @param c elements to be inserted into this Vector
 * @return {@code true} if this Vector changed as a result of the call
 * @throws NullPointerException if the specified collection is null
 * @since 1.2
 */
-public synchronized boolean addAll(Collection<? extends E> c) {
+public boolean addAll(Collection<? extends E> c) {
-modCount++;
 Object[] a = c.toArray();
 int numNew = a.length;
-ensureCapacityHelper(elementCount + numNew);
+if (numNew > 0) {
-System.arraycopy(a, 0, elementData, elementCount, numNew);
+synchronized (this) {
-elementCount += numNew;
+ensureCapacityHelper(elementCount + numNew);
-return numNew != 0;
+System.arraycopy(a, 0, elementData, elementCount, numNew);
+modCount++;
+elementCount += numNew;
+}
+}
+return numNew > 0;
 }
 /**
 * Removes from this Vector all of its elements that are contained in the
 * specified Collection.
 *         ({@code index < 0 || index > size()})
 * @throws NullPointerException if the specified collection is null
 * @since 1.2
 */
 public synchronized boolean addAll(int index, Collection<? extends E> c) {
-modCount++;
 if (index < 0 || index > elementCount)
 throw new ArrayIndexOutOfBoundsException(index);
 Object[] a = c.toArray();
 int numNew = a.length;
-ensureCapacityHelper(elementCount + numNew);
+if (numNew > 0) {
-int numMoved = elementCount - index;
+ensureCapacityHelper(elementCount + numNew);
-if (numMoved > 0)
-System.arraycopy(elementData, index, elementData, index + numNew,
+int numMoved = elementCount - index;
-numMoved);
+if (numMoved > 0)
+System.arraycopy(elementData, index, elementData,
-System.arraycopy(a, 0, elementData, index, numNew);
+index + numNew, numMoved);
-elementCount += numNew;
-return numNew != 0;
+System.arraycopy(a, 0, elementData, index, numNew);
+elementCount += numNew;
+modCount++;
+}
+return numNew > 0;
 }
 /**
 * Compares the specified Object with this Vector for equality.  Returns
 * true if and only if the specified Object is also a List, both Lists
 * Shifts any succeeding elements to the left (reduces their index).
 * This call shortens the list by {@code (toIndex - fromIndex)} elements.
 * (If {@code toIndex==fromIndex}, this operation has no effect.)
 */
 protected synchronized void removeRange(int fromIndex, int toIndex) {
-modCount++;
 int numMoved = elementCount - toIndex;
 System.arraycopy(elementData, toIndex, elementData, fromIndex,
 numMoved);
 // Let gc do its work
+modCount++;
 int newElementCount = elementCount - (toIndex-fromIndex);
 while (elementCount != newElementCount)
 elementData[--elementCount] = null;
 }
 }
 throw new ConcurrentModificationException();
 }
 public long estimateSize() {
-return (long) (getFence() - index);
+return getFence() - index;
 }
 public int characteristics() {
 return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
 }

changeset 24255	91f5e4399160
parent 24196	61c9885d76e2
child 24865	09b1d992ca72