ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/main/java/util/Vector.java

Comparing jsr166/src/main/java/util/Vector.java (file contents):
Revision 1.9 by jsr166, Sun Mar 19 17:59:39 2006 UTC vs.
Revision 1.23 by jsr166, Sun May 18 23:47:56 2008 UTC

#	Line 1 | Line 1
1		/*
2	<	* %W% %E%
2	>	* Copyright 1994-2007 Sun Microsystems, Inc.  All Rights Reserved.
3	>	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4		*
5	<	* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
6	<	* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
5	>	* This code is free software; you can redistribute it and/or modify it
6	>	* under the terms of the GNU General Public License version 2 only, as
7	>	* published by the Free Software Foundation.  Sun designates this
8	>	* particular file as subject to the "Classpath" exception as provided
9	>	* by Sun in the LICENSE file that accompanied this code.
10	>	*
11	>	* This code is distributed in the hope that it will be useful, but WITHOUT
12	>	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13	>	* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14	>	* version 2 for more details (a copy is included in the LICENSE file that
15	>	* accompanied this code).
16	>	*
17	>	* You should have received a copy of the GNU General Public License version
18	>	* 2 along with this work; if not, write to the Free Software Foundation,
19	>	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20	>	*
21	>	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22	>	* CA 95054 USA or visit www.sun.com if you need additional information or
23	>	* have any questions.
24		*/
25
26		package java.util;
27
28		/**
29	<	* The <code>Vector</code> class implements a growable array of
29	>	* The {@code Vector} class implements a growable array of
30		* objects. Like an array, it contains components that can be
31		* accessed using an integer index. However, the size of a
32	<	* <code>Vector</code> can grow or shrink as needed to accommodate
33	<	* adding and removing items after the <code>Vector</code> has been created.
32	>	* {@code Vector} can grow or shrink as needed to accommodate
33	>	* adding and removing items after the {@code Vector} has been created.
34		*
35		* <p>Each vector tries to optimize storage management by maintaining a
36	<	* <code>capacity</code> and a <code>capacityIncrement</code>. The
37	<	* <code>capacity</code> is always at least as large as the vector
36	>	* {@code capacity} and a {@code capacityIncrement}. The
37	>	* {@code capacity} is always at least as large as the vector
38		* size; it is usually larger because as components are added to the
39		* vector, the vector's storage increases in chunks the size of
40	<	* <code>capacityIncrement</code>. An application can increase the
40	>	* {@code capacityIncrement}. An application can increase the
41		* capacity of a vector before inserting a large number of
42		* components; this reduces the amount of incremental reallocation.
43		*
44	<	* <p>The Iterators returned by Vector's iterator and listIterator
45	<	* methods are <em>fail-fast</em>: if the Vector is structurally modified
46	<	* at any time after the Iterator is created, in any way except through the
47	<	* Iterator's own remove or add methods, the Iterator will throw a
48	<	* ConcurrentModificationException.  Thus, in the face of concurrent
49	<	* modification, the Iterator fails quickly and cleanly, rather than risking
50	<	* arbitrary, non-deterministic behavior at an undetermined time in the future.
51	<	* The Enumerations returned by Vector's elements method are <em>not</em>
52	<	* fail-fast.
44	>	* <p><a name="fail-fast"/>
45	>	* The iterators returned by this class's {@link #iterator() iterator} and
46	>	* {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
47	>	* if the vector is structurally modified at any time after the iterator is
48	>	* created, in any way except through the iterator's own
49	>	* {@link ListIterator#remove() remove} or
50	>	* {@link ListIterator#add(Object) add} methods, the iterator will throw a
51	>	* {@link ConcurrentModificationException}.  Thus, in the face of
52	>	* concurrent modification, the iterator fails quickly and cleanly, rather
53	>	* than risking arbitrary, non-deterministic behavior at an undetermined
54	>	* time in the future.  The {@link Enumeration Enumerations} returned by
55	>	* the {@link #elements() elements} method are <em>not</em> fail-fast.
56		*
57		* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
58		* as it is, generally speaking, impossible to make any hard guarantees in the
59		* presence of unsynchronized concurrent modification.  Fail-fast iterators
60	<	* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
60	>	* throw {@code ConcurrentModificationException} on a best-effort basis.
61		* Therefore, it would be wrong to write a program that depended on this
62		* exception for its correctness:  <i>the fail-fast behavior of iterators
63		* should be used only to detect bugs.</i>
64		*
65		* <p>As of the Java 2 platform v1.2, this class was retrofitted to
66		* implement the {@link List} interface, making it a member of the
67	<	* <a href="{@docRoot}/../guide/collections/index.html"> Java
67	>	* <a href="{@docRoot}/../technotes/guides/collections/index.html"> Java
68		* Collections Framework</a>.  Unlike the new collection
69		* implementations, {@code Vector} is synchronized.
70		*
#	Line 63 | Line 84 | public class Vector<E>
84		/**
85		* The array buffer into which the components of the vector are
86		* stored. The capacity of the vector is the length of this array buffer,
87	<	* and is at least large enough to contain all the vector's elements.<p>
87	>	* and is at least large enough to contain all the vector's elements.
88		*
89	<	* Any array elements following the last element in the Vector are null.
89	>	* <p>Any array elements following the last element in the Vector are null.
90		*
91		* @serial
92		*/
93		protected Object[] elementData;
94
95		/**
96	<	* The number of valid components in this <tt>Vector</tt> object.
97	<	* Components <tt>elementData[0]</tt> through
98	<	* <tt>elementData[elementCount-1]</tt> are the actual items.
96	>	* The number of valid components in this {@code Vector} object.
97	>	* Components {@code elementData[0]} through
98	>	* {@code elementData[elementCount-1]} are the actual items.
99		*
100		* @serial
101		*/
#	Line 100 | Line 121 | public class Vector<E>
121		* @param   initialCapacity     the initial capacity of the vector
122		* @param   capacityIncrement   the amount by which the capacity is
123		*                              increased when the vector overflows
124	<	* @exception IllegalArgumentException if the specified initial capacity
125	<	*               is negative
124	>	* @throws IllegalArgumentException if the specified initial capacity
125	>	*         is negative
126		*/
127		public Vector(int initialCapacity, int capacityIncrement) {
128	<	super();
128	>	super();
129		if (initialCapacity < 0)
130		throw new IllegalArgumentException("Illegal Capacity: "+
131		initialCapacity);
132	<	this.elementData = new Object[initialCapacity];
133	<	this.capacityIncrement = capacityIncrement;
132	>	this.elementData = new Object[initialCapacity];
133	>	this.capacityIncrement = capacityIncrement;
134		}
135
136		/**
#	Line 117 | Line 138 | public class Vector<E>
138		* with its capacity increment equal to zero.
139		*
140		* @param   initialCapacity   the initial capacity of the vector
141	<	* @exception IllegalArgumentException if the specified initial capacity
142	<	*               is negative
141	>	* @throws IllegalArgumentException if the specified initial capacity
142	>	*         is negative
143		*/
144		public Vector(int initialCapacity) {
145	<	this(initialCapacity, 0);
145	>	this(initialCapacity, 0);
146		}
147
148		/**
149		* Constructs an empty vector so that its internal data array
150	<	* has size <tt>10</tt> and its standard capacity increment is
150	>	* has size {@code 10} and its standard capacity increment is
151		* zero.
152		*/
153		public Vector() {
154	<	this(10);
154	>	this(10);
155		}
156
157		/**
#	Line 144 | Line 165 | public class Vector<E>
165		* @since   1.2
166		*/
167		public Vector(Collection<? extends E> c) {
168	<	elementData = c.toArray();
169	<	elementCount = elementData.length;
170	<	// c.toArray might (incorrectly) not return Object[] (see 6260652)
171	<	if (elementData.getClass() != Object[].class)
172	<	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
168	>	elementData = c.toArray();
169	>	elementCount = elementData.length;
170	>	// c.toArray might (incorrectly) not return Object[] (see 6260652)
171	>	if (elementData.getClass() != Object[].class)
172	>	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
173		}
174
175		/**
176		* Copies the components of this vector into the specified array.
177	<	* The item at index <tt>k</tt> in this vector is copied into
178	<	* component <tt>k</tt> of <tt>anArray</tt>.
177	>	* The item at index {@code k} in this vector is copied into
178	>	* component {@code k} of {@code anArray}.
179		*
180		* @param  anArray the array into which the components get copied
181		* @throws NullPointerException if the given array is null
#	Line 165 | Line 186 | public class Vector<E>
186		* @see #toArray(Object[])
187		*/
188		public synchronized void copyInto(Object[] anArray) {
189	<	System.arraycopy(elementData, 0, anArray, 0, elementCount);
189	>	System.arraycopy(elementData, 0, anArray, 0, elementCount);
190		}
191
192		/**
193		* Trims the capacity of this vector to be the vector's current
194		* size. If the capacity of this vector is larger than its current
195		* size, then the capacity is changed to equal the size by replacing
196	<	* its internal data array, kept in the field <tt>elementData</tt>,
196	>	* its internal data array, kept in the field {@code elementData},
197		* with a smaller one. An application can use this operation to
198		* minimize the storage of a vector.
199		*/
200		public synchronized void trimToSize() {
201	<	modCount++;
202	<	int oldCapacity = elementData.length;
203	<	if (elementCount < oldCapacity) {
201	>	modCount++;
202	>	int oldCapacity = elementData.length;
203	>	if (elementCount < oldCapacity) {
204		elementData = Arrays.copyOf(elementData, elementCount);
205	<	}
205	>	}
206		}
207
208		/**
#	Line 190 | Line 211 | public class Vector<E>
211		* the minimum capacity argument.
212		*
213		* <p>If the current capacity of this vector is less than
214	<	* <tt>minCapacity</tt>, then its capacity is increased by replacing its
215	<	* internal data array, kept in the field <tt>elementData</tt>, with a
214	>	* {@code minCapacity}, then its capacity is increased by replacing its
215	>	* internal data array, kept in the field {@code elementData}, with a
216		* larger one.  The size of the new data array will be the old size plus
217	<	* <tt>capacityIncrement</tt>, unless the value of
218	<	* <tt>capacityIncrement</tt> is less than or equal to zero, in which case
217	>	* {@code capacityIncrement}, unless the value of
218	>	* {@code capacityIncrement} is less than or equal to zero, in which case
219		* the new capacity will be twice the old capacity; but if this new size
220	<	* is still smaller than <tt>minCapacity</tt>, then the new capacity will
221	<	* be <tt>minCapacity</tt>.
220	>	* is still smaller than {@code minCapacity}, then the new capacity will
221	>	* be {@code minCapacity}.
222		*
223		* @param minCapacity the desired minimum capacity
224		*/
225		public synchronized void ensureCapacity(int minCapacity) {
226	<	modCount++;
227	<	ensureCapacityHelper(minCapacity);
226	>	modCount++;
227	>	ensureCapacityHelper(minCapacity);
228		}
229
230		/**
#	Line 212 | Line 233 | public class Vector<E>
233		* method for ensuring capacity without incurring the cost of an
234		* extra synchronization.
235		*
236	<	* @see java.util.Vector#ensureCapacity(int)
236	>	* @see #ensureCapacity(int)
237		*/
238		private void ensureCapacityHelper(int minCapacity) {
239	<	int oldCapacity = elementData.length;
240	<	if (minCapacity > oldCapacity) {
241	<	Object[] oldData = elementData;
242	<	int newCapacity = (capacityIncrement > 0) ?
243	<	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
244	<	if (newCapacity < minCapacity) {
245	<	newCapacity = minCapacity;
246	<	}
239	>	int oldCapacity = elementData.length;
240	>	if (minCapacity > oldCapacity) {
241	>	Object[] oldData = elementData;
242	>	int newCapacity = (capacityIncrement > 0) ?
243	>	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
244	>	if (newCapacity < minCapacity) {
245	>	newCapacity = minCapacity;
246	>	}
247		elementData = Arrays.copyOf(elementData, newCapacity);
248	<	}
248	>	}
249		}
250
251		/**
252		* Sets the size of this vector. If the new size is greater than the
253	<	* current size, new <code>null</code> items are added to the end of
253	>	* current size, new {@code null} items are added to the end of
254		* the vector. If the new size is less than the current size, all
255	<	* components at index <code>newSize</code> and greater are discarded.
255	>	* components at index {@code newSize} and greater are discarded.
256		*
257	<	* @param   newSize   the new size of this vector
258	<	* @throws  ArrayIndexOutOfBoundsException if new size is negative
257	>	* @param  newSize   the new size of this vector
258	>	* @throws ArrayIndexOutOfBoundsException if the new size is negative
259		*/
260		public synchronized void setSize(int newSize) {
261	<	modCount++;
262	<	if (newSize > elementCount) {
263	<	ensureCapacityHelper(newSize);
264	<	} else {
265	<	for (int i = newSize ; i < elementCount ; i++) {
266	<	elementData[i] = null;
267	<	}
268	<	}
269	<	elementCount = newSize;
261	>	modCount++;
262	>	if (newSize > elementCount) {
263	>	ensureCapacityHelper(newSize);
264	>	} else {
265	>	for (int i = newSize ; i < elementCount ; i++) {
266	>	elementData[i] = null;
267	>	}
268	>	}
269	>	elementCount = newSize;
270		}
271
272		/**
273		* Returns the current capacity of this vector.
274		*
275		* @return  the current capacity (the length of its internal
276	<	*          data array, kept in the field <tt>elementData</tt>
276	>	*          data array, kept in the field {@code elementData}
277		*          of this vector)
278		*/
279		public synchronized int capacity() {
280	<	return elementData.length;
280	>	return elementData.length;
281		}
282
283		/**
#	Line 265 | Line 286 | public class Vector<E>
286		* @return  the number of components in this vector
287		*/
288		public synchronized int size() {
289	<	return elementCount;
289	>	return elementCount;
290		}
291
292		/**
293		* Tests if this vector has no components.
294		*
295	<	* @return  <code>true</code> if and only if this vector has
295	>	* @return  {@code true} if and only if this vector has
296		*          no components, that is, its size is zero;
297	<	*          <code>false</code> otherwise.
297	>	*          {@code false} otherwise.
298		*/
299		public synchronized boolean isEmpty() {
300	<	return elementCount == 0;
300	>	return elementCount == 0;
301		}
302
303		/**
304		* Returns an enumeration of the components of this vector. The
305	<	* returned <tt>Enumeration</tt> object will generate all items in
306	<	* this vector. The first item generated is the item at index <tt>0</tt>,
307	<	* then the item at index <tt>1</tt>, and so on.
305	>	* returned {@code Enumeration} object will generate all items in
306	>	* this vector. The first item generated is the item at index {@code 0},
307	>	* then the item at index {@code 1}, and so on.
308		*
309		* @return  an enumeration of the components of this vector
289	–	* @see     Enumeration
310		* @see     Iterator
311		*/
312		public Enumeration<E> elements() {
313	<	return new Enumeration<E>() {
314	<	int count = 0;
313	>	return new Enumeration<E>() {
314	>	int count = 0;
315
316	<	public boolean hasMoreElements() {
317	<	return count < elementCount;
318	<	}
319	<
320	<	public E nextElement() {
321	<	synchronized (Vector.this) {
322	<	if (count < elementCount) {
323	<	return (E)elementData[count++];
324	<	}
325	<	}
326	<	throw new NoSuchElementException("Vector Enumeration");
327	<	}
328	<	};
316	>	public boolean hasMoreElements() {
317	>	return count < elementCount;
318	>	}
319	>
320	>	public E nextElement() {
321	>	synchronized (Vector.this) {
322	>	if (count < elementCount) {
323	>	return elementData(count++);
324	>	}
325	>	}
326	>	throw new NoSuchElementException("Vector Enumeration");
327	>	}
328	>	};
329		}
330
331		/**
332	<	* Returns <tt>true</tt> if this vector contains the specified element.
333	<	* More formally, returns <tt>true</tt> if and only if this vector
334	<	* contains at least one element <tt>e</tt> such that
332	>	* Returns {@code true} if this vector contains the specified element.
333	>	* More formally, returns {@code true} if and only if this vector
334	>	* contains at least one element {@code e} such that
335		* <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
336		*
337		* @param o element whose presence in this vector is to be tested
338	<	* @return <tt>true</tt> if this vector contains the specified element
338	>	* @return {@code true} if this vector contains the specified element
339		*/
340		public boolean contains(Object o) {
341	<	return indexOf(o, 0) >= 0;
341	>	return indexOf(o, 0) >= 0;
342		}
343
344		/**
345		* Returns the index of the first occurrence of the specified element
346		* in this vector, or -1 if this vector does not contain the element.
347	<	* More formally, returns the lowest index <tt>i</tt> such that
347	>	* More formally, returns the lowest index {@code i} such that
348		* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
349		* or -1 if there is no such index.
350		*
#	Line 333 | Line 353 | public class Vector<E>
353		*         this vector, or -1 if this vector does not contain the element
354		*/
355		public int indexOf(Object o) {
356	<	return indexOf(o, 0);
356	>	return indexOf(o, 0);
357		}
358
359		/**
360		* Returns the index of the first occurrence of the specified element in
361	<	* this vector, searching forwards from <tt>index</tt>, or returns -1 if
361	>	* this vector, searching forwards from {@code index}, or returns -1 if
362		* the element is not found.
363	<	* More formally, returns the lowest index <tt>i</tt> such that
363	>	* More formally, returns the lowest index {@code i} such that
364		* <tt>(i&nbsp;&gt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
365		* or -1 if there is no such index.
366		*
367		* @param o element to search for
368		* @param index index to start searching from
369		* @return the index of the first occurrence of the element in
370	<	*         this vector at position <tt>index</tt> or later in the vector;
371	<	*         <tt>-1</tt> if the element is not found.
370	>	*         this vector at position {@code index} or later in the vector;
371	>	*         {@code -1} if the element is not found.
372		* @throws IndexOutOfBoundsException if the specified index is negative
373		* @see     Object#equals(Object)
374		*/
375		public synchronized int indexOf(Object o, int index) {
376	<	if (o == null) {
377	<	for (int i = index ; i < elementCount ; i++)
378	<	if (elementData[i]==null)
379	<	return i;
380	<	} else {
381	<	for (int i = index ; i < elementCount ; i++)
382	<	if (o.equals(elementData[i]))
383	<	return i;
384	<	}
385	<	return -1;
376	>	if (o == null) {
377	>	for (int i = index ; i < elementCount ; i++)
378	>	if (elementData[i]==null)
379	>	return i;
380	>	} else {
381	>	for (int i = index ; i < elementCount ; i++)
382	>	if (o.equals(elementData[i]))
383	>	return i;
384	>	}
385	>	return -1;
386		}
387
388		/**
389		* Returns the index of the last occurrence of the specified element
390		* in this vector, or -1 if this vector does not contain the element.
391	<	* More formally, returns the highest index <tt>i</tt> such that
391	>	* More formally, returns the highest index {@code i} such that
392		* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
393		* or -1 if there is no such index.
394		*
#	Line 377 | Line 397 | public class Vector<E>
397		*         this vector, or -1 if this vector does not contain the element
398		*/
399		public synchronized int lastIndexOf(Object o) {
400	<	return lastIndexOf(o, elementCount-1);
400	>	return lastIndexOf(o, elementCount-1);
401		}
402
403		/**
404		* Returns the index of the last occurrence of the specified element in
405	<	* this vector, searching backwards from <tt>index</tt>, or returns -1 if
405	>	* this vector, searching backwards from {@code index}, or returns -1 if
406		* the element is not found.
407	<	* More formally, returns the highest index <tt>i</tt> such that
407	>	* More formally, returns the highest index {@code i} such that
408		* <tt>(i&nbsp;&lt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
409		* or -1 if there is no such index.
410		*
411		* @param o element to search for
412		* @param index index to start searching backwards from
413		* @return the index of the last occurrence of the element at position
414	<	*         less than or equal to <tt>index</tt> in this vector;
414	>	*         less than or equal to {@code index} in this vector;
415		*         -1 if the element is not found.
416		* @throws IndexOutOfBoundsException if the specified index is greater
417		*         than or equal to the current size of this vector
#	Line 400 | Line 420 | public class Vector<E>
420		if (index >= elementCount)
421		throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
422
423	<	if (o == null) {
424	<	for (int i = index; i >= 0; i--)
425	<	if (elementData[i]==null)
426	<	return i;
427	<	} else {
428	<	for (int i = index; i >= 0; i--)
429	<	if (o.equals(elementData[i]))
430	<	return i;
431	<	}
432	<	return -1;
423	>	if (o == null) {
424	>	for (int i = index; i >= 0; i--)
425	>	if (elementData[i]==null)
426	>	return i;
427	>	} else {
428	>	for (int i = index; i >= 0; i--)
429	>	if (o.equals(elementData[i]))
430	>	return i;
431	>	}
432	>	return -1;
433		}
434
435		/**
436	<	* Returns the component at the specified index.<p>
436	>	* Returns the component at the specified index.
437		*
438	<	* This method is identical in functionality to the get method
439	<	* (which is part of the List interface).
438	>	* <p>This method is identical in functionality to the {@link #get(int)}
439	>	* method (which is part of the {@link List} interface).
440		*
441		* @param      index   an index into this vector
442		* @return     the component at the specified index
443	<	* @exception  ArrayIndexOutOfBoundsException  if the <tt>index</tt>
444	<	*             is negative or not less than the current size of this
425	<	*             <tt>Vector</tt> object.
426	<	* @see        #get(int)
427	<	* @see        List
443	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
444	>	*         ({@code index < 0 || index >= size()})
445		*/
446		public synchronized E elementAt(int index) {
447	<	if (index >= elementCount) {
448	<	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
449	<	}
447	>	if (index >= elementCount) {
448	>	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
449	>	}
450
451	<	return (E)elementData[index];
451	>	return elementData(index);
452		}
453
454		/**
455	<	* Returns the first component (the item at index <tt>0</tt>) of
455	>	* Returns the first component (the item at index {@code 0}) of
456		* this vector.
457		*
458		* @return     the first component of this vector
459	<	* @exception  NoSuchElementException  if this vector has no components
459	>	* @throws NoSuchElementException if this vector has no components
460		*/
461		public synchronized E firstElement() {
462	<	if (elementCount == 0) {
463	<	throw new NoSuchElementException();
464	<	}
465	<	return (E)elementData[0];
462	>	if (elementCount == 0) {
463	>	throw new NoSuchElementException();
464	>	}
465	>	return elementData(0);
466		}
467
468		/**
#	Line 453 | Line 470 | public class Vector<E>
470		*
471		* @return  the last component of the vector, i.e., the component at index
472		*          <code>size()&nbsp;-&nbsp;1</code>.
473	<	* @exception  NoSuchElementException  if this vector is empty
473	>	* @throws NoSuchElementException if this vector is empty
474		*/
475		public synchronized E lastElement() {
476	<	if (elementCount == 0) {
477	<	throw new NoSuchElementException();
478	<	}
479	<	return (E)elementData[elementCount - 1];
476	>	if (elementCount == 0) {
477	>	throw new NoSuchElementException();
478	>	}
479	>	return elementData(elementCount - 1);
480		}
481
482		/**
483	<	* Sets the component at the specified <code>index</code> of this
483	>	* Sets the component at the specified {@code index} of this
484		* vector to be the specified object. The previous component at that
485	<	* position is discarded.<p>
485	>	* position is discarded.
486		*
487	<	* The index must be a value greater than or equal to <code>0</code>
488	<	* and less than the current size of the vector. <p>
487	>	* <p>The index must be a value greater than or equal to {@code 0}
488	>	* and less than the current size of the vector.
489		*
490	<	* This method is identical in functionality to the set method
491	<	* (which is part of the List interface). Note that the set method reverses
492	<	* the order of the parameters, to more closely match array usage.  Note
493	<	* also that the set method returns the old value that was stored at the
494	<	* specified position.
490	>	* <p>This method is identical in functionality to the
491	>	* {@link #set(int, Object) set(int, E)}
492	>	* method (which is part of the {@link List} interface). Note that the
493	>	* {@code set} method reverses the order of the parameters, to more closely
494	>	* match array usage.  Note also that the {@code set} method returns the
495	>	* old value that was stored at the specified position.
496		*
497		* @param      obj     what the component is to be set to
498		* @param      index   the specified index
499	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
500	<	* @see        #size()
483	<	* @see        List
484	<	* @see        #set(int, java.lang.Object)
499	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
500	>	*         ({@code index < 0 || index >= size()})
501		*/
502		public synchronized void setElementAt(E obj, int index) {
503	<	if (index >= elementCount) {
504	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
505	<	elementCount);
506	<	}
507	<	elementData[index] = obj;
503	>	if (index >= elementCount) {
504	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
505	>	elementCount);
506	>	}
507	>	elementData[index] = obj;
508		}
509
510		/**
511		* Deletes the component at the specified index. Each component in
512		* this vector with an index greater or equal to the specified
513	<	* <code>index</code> is shifted downward to have an index one
513	>	* {@code index} is shifted downward to have an index one
514		* smaller than the value it had previously. The size of this vector
515	<	* is decreased by <tt>1</tt>.<p>
515	>	* is decreased by {@code 1}.
516		*
517	<	* The index must be a value greater than or equal to <code>0</code>
518	<	* and less than the current size of the vector. <p>
517	>	* <p>The index must be a value greater than or equal to {@code 0}
518	>	* and less than the current size of the vector.
519		*
520	<	* This method is identical in functionality to the remove method
521	<	* (which is part of the List interface).  Note that the remove method
522	<	* returns the old value that was stored at the specified position.
520	>	* <p>This method is identical in functionality to the {@link #remove(int)}
521	>	* method (which is part of the {@link List} interface).  Note that the
522	>	* {@code remove} method returns the old value that was stored at the
523	>	* specified position.
524		*
525		* @param      index   the index of the object to remove
526	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
527	<	* @see        #size()
511	<	* @see        #remove(int)
512	<	* @see        List
526	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
527	>	*         ({@code index < 0 || index >= size()})
528		*/
529		public synchronized void removeElementAt(int index) {
530	<	modCount++;
531	<	if (index >= elementCount) {
532	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
533	<	elementCount);
534	<	}
535	<	else if (index < 0) {
536	<	throw new ArrayIndexOutOfBoundsException(index);
537	<	}
538	<	int j = elementCount - index - 1;
539	<	if (j > 0) {
540	<	System.arraycopy(elementData, index + 1, elementData, index, j);
541	<	}
542	<	elementCount--;
543	<	elementData[elementCount] = null; /* to let gc do its work */
530	>	modCount++;
531	>	if (index >= elementCount) {
532	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
533	>	elementCount);
534	>	}
535	>	else if (index < 0) {
536	>	throw new ArrayIndexOutOfBoundsException(index);
537	>	}
538	>	int j = elementCount - index - 1;
539	>	if (j > 0) {
540	>	System.arraycopy(elementData, index + 1, elementData, index, j);
541	>	}
542	>	elementCount--;
543	>	elementData[elementCount] = null; /* to let gc do its work */
544		}
545
546		/**
547		* Inserts the specified object as a component in this vector at the
548	<	* specified <code>index</code>. Each component in this vector with
549	<	* an index greater or equal to the specified <code>index</code> is
548	>	* specified {@code index}. Each component in this vector with
549	>	* an index greater or equal to the specified {@code index} is
550		* shifted upward to have an index one greater than the value it had
551	<	* previously. <p>
551	>	* previously.
552		*
553	<	* The index must be a value greater than or equal to <code>0</code>
553	>	* <p>The index must be a value greater than or equal to {@code 0}
554		* and less than or equal to the current size of the vector. (If the
555		* index is equal to the current size of the vector, the new element
556	<	* is appended to the Vector.)<p>
556	>	* is appended to the Vector.)
557		*
558	<	* This method is identical in functionality to the add(Object, int) method
559	<	* (which is part of the List interface). Note that the add method reverses
560	<	* the order of the parameters, to more closely match array usage.
558	>	* <p>This method is identical in functionality to the
559	>	* {@link #add(int, Object) add(int, E)}
560	>	* method (which is part of the {@link List} interface).  Note that the
561	>	* {@code add} method reverses the order of the parameters, to more closely
562	>	* match array usage.
563		*
564		* @param      obj     the component to insert
565		* @param      index   where to insert the new component
566	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
567	<	* @see        #size()
551	<	* @see        #add(int, Object)
552	<	* @see        List
566	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
567	>	*         ({@code index < 0 || index > size()})
568		*/
569		public synchronized void insertElementAt(E obj, int index) {
570	<	modCount++;
571	<	if (index > elementCount) {
572	<	throw new ArrayIndexOutOfBoundsException(index
573	<	+ " > " + elementCount);
574	<	}
575	<	ensureCapacityHelper(elementCount + 1);
576	<	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
577	<	elementData[index] = obj;
578	<	elementCount++;
570	>	modCount++;
571	>	if (index > elementCount) {
572	>	throw new ArrayIndexOutOfBoundsException(index
573	>	+ " > " + elementCount);
574	>	}
575	>	ensureCapacityHelper(elementCount + 1);
576	>	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
577	>	elementData[index] = obj;
578	>	elementCount++;
579		}
580
581		/**
582		* Adds the specified component to the end of this vector,
583		* increasing its size by one. The capacity of this vector is
584	<	* increased if its size becomes greater than its capacity. <p>
584	>	* increased if its size becomes greater than its capacity.
585		*
586	<	* This method is identical in functionality to the add(Object) method
587	<	* (which is part of the List interface).
586	>	* <p>This method is identical in functionality to the
587	>	* {@link #add(Object) add(E)}
588	>	* method (which is part of the {@link List} interface).
589		*
590		* @param   obj   the component to be added
575	–	* @see        #add(Object)
576	–	* @see        List
591		*/
592		public synchronized void addElement(E obj) {
593	<	modCount++;
594	<	ensureCapacityHelper(elementCount + 1);
595	<	elementData[elementCount++] = obj;
593	>	modCount++;
594	>	ensureCapacityHelper(elementCount + 1);
595	>	elementData[elementCount++] = obj;
596		}
597
598		/**
#	Line 586 | Line 600 | public class Vector<E>
600		* from this vector. If the object is found in this vector, each
601		* component in the vector with an index greater or equal to the
602		* object's index is shifted downward to have an index one smaller
603	<	* than the value it had previously.<p>
603	>	* than the value it had previously.
604		*
605	<	* This method is identical in functionality to the remove(Object)
606	<	* method (which is part of the List interface).
605	>	* <p>This method is identical in functionality to the
606	>	* {@link #remove(Object)} method (which is part of the
607	>	* {@link List} interface).
608		*
609		* @param   obj   the component to be removed
610	<	* @return  <code>true</code> if the argument was a component of this
611	<	*          vector; <code>false</code> otherwise.
597	<	* @see     List#remove(Object)
598	<	* @see     List
610	>	* @return  {@code true} if the argument was a component of this
611	>	*          vector; {@code false} otherwise.
612		*/
613		public synchronized boolean removeElement(Object obj) {
614	<	modCount++;
615	<	int i = indexOf(obj);
616	<	if (i >= 0) {
617	<	removeElementAt(i);
618	<	return true;
619	<	}
620	<	return false;
614	>	modCount++;
615	>	int i = indexOf(obj);
616	>	if (i >= 0) {
617	>	removeElementAt(i);
618	>	return true;
619	>	}
620	>	return false;
621		}
622
623		/**
624	<	* Removes all components from this vector and sets its size to zero.<p>
612	<	*
613	<	* This method is identical in functionality to the clear method
614	<	* (which is part of the List interface).
624	>	* Removes all components from this vector and sets its size to zero.
625		*
626	<	* @see     #clear
627	<	* @see     List
626	>	* <p>This method is identical in functionality to the {@link #clear}
627	>	* method (which is part of the {@link List} interface).
628		*/
629		public synchronized void removeAllElements() {
630		modCount++;
631	<	// Let gc do its work
632	<	for (int i = 0; i < elementCount; i++)
633	<	elementData[i] = null;
631	>	// Let gc do its work
632	>	for (int i = 0; i < elementCount; i++)
633	>	elementData[i] = null;
634
635	<	elementCount = 0;
635	>	elementCount = 0;
636		}
637
638		/**
639		* Returns a clone of this vector. The copy will contain a
640		* reference to a clone of the internal data array, not a reference
641	<	* to the original internal data array of this <tt>Vector</tt> object.
641	>	* to the original internal data array of this {@code Vector} object.
642		*
643		* @return  a clone of this vector
644		*/
645		public synchronized Object clone() {
646	<	try {
647	<	Vector<E> v = (Vector<E>) super.clone();
648	<	v.elementData = Arrays.copyOf(elementData, elementCount);
649	<	v.modCount = 0;
650	<	return v;
651	<	} catch (CloneNotSupportedException e) {
652	<	// this shouldn't happen, since we are Cloneable
653	<	throw new InternalError();
654	<	}
646	>	try {
647	>	@SuppressWarnings("unchecked")
648	>	Vector<E> v = (Vector<E>) super.clone();
649	>	v.elementData = Arrays.copyOf(elementData, elementCount);
650	>	v.modCount = 0;
651	>	return v;
652	>	} catch (CloneNotSupportedException e) {
653	>	// this shouldn't happen, since we are Cloneable
654	>	throw new InternalError();
655	>	}
656		}
657
658		/**
#	Line 659 | Line 670 | public class Vector<E>
670		* correct order; the runtime type of the returned array is that of the
671		* specified array.  If the Vector fits in the specified array, it is
672		* returned therein.  Otherwise, a new array is allocated with the runtime
673	<	* type of the specified array and the size of this Vector.<p>
673	>	* type of the specified array and the size of this Vector.
674		*
675	<	* If the Vector fits in the specified array with room to spare
675	>	* <p>If the Vector fits in the specified array with room to spare
676		* (i.e., the array has more elements than the Vector),
677		* the element in the array immediately following the end of the
678		* Vector is set to null.  (This is useful in determining the length
#	Line 669 | Line 680 | public class Vector<E>
680		* does not contain any null elements.)
681		*
682		* @param a the array into which the elements of the Vector are to
683	<	*          be stored, if it is big enough; otherwise, a new array of the
684	<	*          same runtime type is allocated for this purpose.
683	>	*          be stored, if it is big enough; otherwise, a new array of the
684	>	*          same runtime type is allocated for this purpose.
685		* @return an array containing the elements of the Vector
686	<	* @exception ArrayStoreException the runtime type of a is not a supertype
686	>	* @throws ArrayStoreException if the runtime type of a is not a supertype
687		* of the runtime type of every element in this Vector
688		* @throws NullPointerException if the given array is null
689		* @since 1.2
690		*/
691	+	@SuppressWarnings("unchecked")
692		public synchronized <T> T[] toArray(T[] a) {
693		if (a.length < elementCount)
694		return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
695
696	<	System.arraycopy(elementData, 0, a, 0, elementCount);
696	>	System.arraycopy(elementData, 0, a, 0, elementCount);
697
698		if (a.length > elementCount)
699		a[elementCount] = null;
#	Line 691 | Line 703 | public class Vector<E>
703
704		// Positional Access Operations
705
706	+	@SuppressWarnings("unchecked")
707	+	E elementData(int index) {
708	+	return (E) elementData[index];
709	+	}
710	+
711		/**
712		* Returns the element at the specified position in this Vector.
713		*
714		* @param index index of the element to return
715		* @return object at the specified index
716	<	* @exception ArrayIndexOutOfBoundsException index is out of range (index
717	<	*            &lt; 0 || index &gt;= size())
716	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
717	>	*            ({@code index < 0 || index >= size()})
718		* @since 1.2
719		*/
720		public synchronized E get(int index) {
721	<	if (index >= elementCount)
722	<	throw new ArrayIndexOutOfBoundsException(index);
721	>	if (index >= elementCount)
722	>	throw new ArrayIndexOutOfBoundsException(index);
723
724	<	return (E)elementData[index];
724	>	return elementData(index);
725		}
726
727		/**
#	Line 714 | Line 731 | public class Vector<E>
731		* @param index index of the element to replace
732		* @param element element to be stored at the specified position
733		* @return the element previously at the specified position
734	<	* @exception ArrayIndexOutOfBoundsException index out of range
735	<	*            (index &lt; 0 || index &gt;= size())
734	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
735	>	*         ({@code index < 0 || index >= size()})
736		* @since 1.2
737		*/
738		public synchronized E set(int index, E element) {
739	<	if (index >= elementCount)
740	<	throw new ArrayIndexOutOfBoundsException(index);
739	>	if (index >= elementCount)
740	>	throw new ArrayIndexOutOfBoundsException(index);
741
742	<	Object oldValue = elementData[index];
743	<	elementData[index] = element;
744	<	return (E)oldValue;
742	>	E oldValue = elementData(index);
743	>	elementData[index] = element;
744	>	return oldValue;
745		}
746
747		/**
748		* Appends the specified element to the end of this Vector.
749		*
750		* @param e element to be appended to this Vector
751	<	* @return <tt>true</tt> (as specified by {@link Collection#add})
751	>	* @return {@code true} (as specified by {@link Collection#add})
752		* @since 1.2
753		*/
754		public synchronized boolean add(E e) {
755	<	modCount++;
756	<	ensureCapacityHelper(elementCount + 1);
757	<	elementData[elementCount++] = e;
755	>	modCount++;
756	>	ensureCapacityHelper(elementCount + 1);
757	>	elementData[elementCount++] = e;
758		return true;
759		}
760
#	Line 745 | Line 762 | public class Vector<E>
762		* Removes the first occurrence of the specified element in this Vector
763		* If the Vector does not contain the element, it is unchanged.  More
764		* formally, removes the element with the lowest index i such that
765	<	* <code>(o==null ? get(i)==null : o.equals(get(i)))</code> (if such
765	>	* {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
766		* an element exists).
767		*
768		* @param o element to be removed from this Vector, if present
#	Line 763 | Line 780 | public class Vector<E>
780		*
781		* @param index index at which the specified element is to be inserted
782		* @param element element to be inserted
783	<	* @exception ArrayIndexOutOfBoundsException index is out of range
784	<	*            (index &lt; 0 || index &gt; size())
783	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
784	>	*         ({@code index < 0 || index > size()})
785		* @since 1.2
786		*/
787		public void add(int index, E element) {
#	Line 776 | Line 793 | public class Vector<E>
793		* Shifts any subsequent elements to the left (subtracts one from their
794		* indices).  Returns the element that was removed from the Vector.
795		*
796	<	* @exception ArrayIndexOutOfBoundsException index out of range (index
797	<	*            &lt; 0 || index &gt;= size())
796	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
797	>	*         ({@code index < 0 || index >= size()})
798		* @param index the index of the element to be removed
799		* @return element that was removed
800		* @since 1.2
801		*/
802		public synchronized E remove(int index) {
803	<	modCount++;
804	<	if (index >= elementCount)
805	<	throw new ArrayIndexOutOfBoundsException(index);
806	<	Object oldValue = elementData[index];
790	<
791	<	int numMoved = elementCount - index - 1;
792	<	if (numMoved > 0)
793	<	System.arraycopy(elementData, index+1, elementData, index,
794	<	numMoved);
795	<	elementData[--elementCount] = null; // Let gc do its work
803	>	modCount++;
804	>	if (index >= elementCount)
805	>	throw new ArrayIndexOutOfBoundsException(index);
806	>	E oldValue = elementData(index);
807
808	<	return (E)oldValue;
808	>	int numMoved = elementCount - index - 1;
809	>	if (numMoved > 0)
810	>	System.arraycopy(elementData, index+1, elementData, index,
811	>	numMoved);
812	>	elementData[--elementCount] = null; // Let gc do its work
813	>
814	>	return oldValue;
815		}
816
817		/**
#	Line 816 | Line 833 | public class Vector<E>
833		* @param   c a collection whose elements will be tested for containment
834		*          in this Vector
835		* @return true if this Vector contains all of the elements in the
836	<	*         specified collection
836	>	*         specified collection
837		* @throws NullPointerException if the specified collection is null
838		*/
839		public synchronized boolean containsAll(Collection<?> c) {
#	Line 832 | Line 849 | public class Vector<E>
849		* specified Collection is this Vector, and this Vector is nonempty.)
850		*
851		* @param c elements to be inserted into this Vector
852	<	* @return <tt>true</tt> if this Vector changed as a result of the call
852	>	* @return {@code true} if this Vector changed as a result of the call
853		* @throws NullPointerException if the specified collection is null
854		* @since 1.2
855		*/
856		public synchronized boolean addAll(Collection<? extends E> c) {
857	<	modCount++;
857	>	modCount++;
858		Object[] a = c.toArray();
859		int numNew = a.length;
860	<	ensureCapacityHelper(elementCount + numNew);
860	>	ensureCapacityHelper(elementCount + numNew);
861		System.arraycopy(a, 0, elementData, elementCount, numNew);
862		elementCount += numNew;
863	<	return numNew != 0;
863	>	return numNew != 0;
864		}
865
866		/**
#	Line 895 | Line 912 | public class Vector<E>
912		* @param index index at which to insert the first element from the
913		*              specified collection
914		* @param c elements to be inserted into this Vector
915	<	* @return <tt>true</tt> if this Vector changed as a result of the call
916	<	* @exception ArrayIndexOutOfBoundsException index out of range (index
917	<	*            &lt; 0 || index &gt; size())
915	>	* @return {@code true} if this Vector changed as a result of the call
916	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
917	>	*         ({@code index < 0 || index > size()})
918		* @throws NullPointerException if the specified collection is null
919		* @since 1.2
920		*/
921		public synchronized boolean addAll(int index, Collection<? extends E> c) {
922	<	modCount++;
923	<	if (index < 0 || index > elementCount)
924	<	throw new ArrayIndexOutOfBoundsException(index);
922	>	modCount++;
923	>	if (index < 0 || index > elementCount)
924	>	throw new ArrayIndexOutOfBoundsException(index);
925
926		Object[] a = c.toArray();
927	<	int numNew = a.length;
928	<	ensureCapacityHelper(elementCount + numNew);
927	>	int numNew = a.length;
928	>	ensureCapacityHelper(elementCount + numNew);
929
930	<	int numMoved = elementCount - index;
931	<	if (numMoved > 0)
932	<	System.arraycopy(elementData, index, elementData, index + numNew,
933	<	numMoved);
930	>	int numMoved = elementCount - index;
931	>	if (numMoved > 0)
932	>	System.arraycopy(elementData, index, elementData, index + numNew,
933	>	numMoved);
934
935		System.arraycopy(a, 0, elementData, index, numNew);
936	<	elementCount += numNew;
937	<	return numNew != 0;
936	>	elementCount += numNew;
937	>	return numNew != 0;
938		}
939
940		/**
941		* Compares the specified Object with this Vector for equality.  Returns
942		* true if and only if the specified Object is also a List, both Lists
943		* have the same size, and all corresponding pairs of elements in the two
944	<	* Lists are <em>equal</em>.  (Two elements <code>e1</code> and
945	<	* <code>e2</code> are <em>equal</em> if <code>(e1==null ? e2==null :
946	<	* e1.equals(e2))</code>.)  In other words, two Lists are defined to be
944	>	* Lists are <em>equal</em>.  (Two elements {@code e1} and
945	>	* {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
946	>	* e1.equals(e2))}.)  In other words, two Lists are defined to be
947		* equal if they contain the same elements in the same order.
948		*
949		* @param o the Object to be compared for equality with this Vector
#	Line 957 | Line 974 | public class Vector<E>
974		* equal, the returned List is empty.)  The returned List is backed by this
975		* List, so changes in the returned List are reflected in this List, and
976		* vice-versa.  The returned List supports all of the optional List
977	<	* operations supported by this List.<p>
977	>	* operations supported by this List.
978		*
979	<	* This method eliminates the need for explicit range operations (of
980	<	* the sort that commonly exist for arrays).   Any operation that expects
979	>	* <p>This method eliminates the need for explicit range operations (of
980	>	* the sort that commonly exist for arrays).  Any operation that expects
981		* a List can be used as a range operation by operating on a subList view
982		* instead of a whole List.  For example, the following idiom
983		* removes a range of elements from a List:
984		* <pre>
985	<	*      list.subList(from, to).clear();
985	>	*      list.subList(from, to).clear();
986		* </pre>
987		* Similar idioms may be constructed for indexOf and lastIndexOf,
988		* and all of the algorithms in the Collections class can be applied to
989	<	* a subList.<p>
989	>	* a subList.
990		*
991	<	* The semantics of the List returned by this method become undefined if
991	>	* <p>The semantics of the List returned by this method become undefined if
992		* the backing list (i.e., this List) is <i>structurally modified</i> in
993		* any way other than via the returned List.  (Structural modifications are
994		* those that change the size of the List, or otherwise perturb it in such
#	Line 980 | Line 997 | public class Vector<E>
997		* @param fromIndex low endpoint (inclusive) of the subList
998		* @param toIndex high endpoint (exclusive) of the subList
999		* @return a view of the specified range within this List
1000	<	* @throws IndexOutOfBoundsException endpoint index value out of range
1001	<	*         <code>(fromIndex &lt; 0 || toIndex &gt; size)</code>
1002	<	* @throws IllegalArgumentException endpoint indices out of order
1003	<	*         <code>(fromIndex &gt; toIndex)</code>
1000	>	* @throws IndexOutOfBoundsException if an endpoint index value is out of range
1001	>	*         {@code (fromIndex < 0 || toIndex > size)}
1002	>	* @throws IllegalArgumentException if the endpoint indices are out of order
1003	>	*         {@code (fromIndex > toIndex)}
1004		*/
1005		public synchronized List<E> subList(int fromIndex, int toIndex) {
1006		return Collections.synchronizedList(super.subList(fromIndex, toIndex),
#	Line 991 | Line 1008 | public class Vector<E>
1008		}
1009
1010		/**
1011	<	* Removes from this List all of the elements whose index is between
1012	<	* fromIndex, inclusive and toIndex, exclusive.  Shifts any succeeding
1013	<	* elements to the left (reduces their index).
1014	<	* This call shortens the ArrayList by (toIndex - fromIndex) elements.  (If
1015	<	* toIndex==fromIndex, this operation has no effect.)
999	<	*
1000	<	* @param fromIndex index of first element to be removed
1001	<	* @param toIndex index after last element to be removed
1011	>	* Removes from this list all of the elements whose index is between
1012	>	* {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.
1013	>	* Shifts any succeeding elements to the left (reduces their index).
1014	>	* This call shortens the list by {@code (toIndex - fromIndex)} elements.
1015	>	* (If {@code toIndex==fromIndex}, this operation has no effect.)
1016		*/
1017		protected synchronized void removeRange(int fromIndex, int toIndex) {
1018	<	modCount++;
1019	<	int numMoved = elementCount - toIndex;
1018	>	modCount++;
1019	>	int numMoved = elementCount - toIndex;
1020		System.arraycopy(elementData, toIndex, elementData, fromIndex,
1021		numMoved);
1022
1023	<	// Let gc do its work
1024	<	int newElementCount = elementCount - (toIndex-fromIndex);
1025	<	while (elementCount != newElementCount)
1026	<	elementData[--elementCount] = null;
1023	>	// Let gc do its work
1024	>	int newElementCount = elementCount - (toIndex-fromIndex);
1025	>	while (elementCount != newElementCount)
1026	>	elementData[--elementCount] = null;
1027		}
1028
1029		/**
1030	<	* Save the state of the <tt>Vector</tt> instance to a stream (that
1030	>	* Save the state of the {@code Vector} instance to a stream (that
1031		* is, serialize it).  This method is present merely for synchronization.
1032		* It just calls the default writeObject method.
1033		*/
1034		private synchronized void writeObject(java.io.ObjectOutputStream s)
1035		throws java.io.IOException
1036		{
1037	<	s.defaultWriteObject();
1037	>	s.defaultWriteObject();
1038		}
1039
1040		/**
1041	<	* Returns a list-iterator of the elements in this list (in proper
1041	>	* Returns a list iterator over the elements in this list (in proper
1042		* sequence), starting at the specified position in the list.
1043	<	* Obeys the general contract of <tt>List.listIterator(int)</tt>.<p>
1043	>	* The specified index indicates the first element that would be
1044	>	* returned by an initial call to {@link ListIterator#next next}.
1045	>	* An initial call to {@link ListIterator#previous previous} would
1046	>	* return the element with the specified index minus one.
1047	>	*
1048	>	* <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1049		*
1031	–	* The list-iterator is <i>fail-fast</i>: if the list is structurally
1032	–	* modified at any time after the Iterator is created, in any way except
1033	–	* through the list-iterator's own <tt>remove</tt> or <tt>add</tt>
1034	–	* methods, the list-iterator will throw a
1035	–	* <tt>ConcurrentModificationException</tt>.  Thus, in the face of
1036	–	* concurrent modification, the iterator fails quickly and cleanly, rather
1037	–	* than risking arbitrary, non-deterministic behavior at an undetermined
1038	–	* time in the future.
1039	–	*
1040	–	* @param index index of the first element to be returned from the
1041	–	*              list-iterator (by a call to <tt>next</tt>)
1042	–	* @return a ListIterator of the elements in this list (in proper
1043	–	*         sequence), starting at the specified position in the list
1050		* @throws IndexOutOfBoundsException {@inheritDoc}
1045	–	* @see List#listIterator(int)
1051		*/
1052		public synchronized ListIterator<E> listIterator(int index) {
1053	<	if (index < 0 || index > elementCount)
1053	>	if (index < 0 || index > elementCount)
1054		throw new IndexOutOfBoundsException("Index: "+index);
1055	<	return new VectorIterator(index);
1055	>	return new ListItr(index);
1056		}
1057
1058		/**
1059	<	* {@inheritDoc}
1059	>	* Returns a list iterator over the elements in this list (in proper
1060	>	* sequence).
1061	>	*
1062	>	* <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1063	>	*
1064	>	* @see #listIterator(int)
1065		*/
1066		public synchronized ListIterator<E> listIterator() {
1067	<	return new VectorIterator(0);
1067	>	return new ListItr(0);
1068		}
1069
1070		/**
1071		* Returns an iterator over the elements in this list in proper sequence.
1072		*
1073	+	* <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1074	+	*
1075		* @return an iterator over the elements in this list in proper sequence
1076		*/
1077		public synchronized Iterator<E> iterator() {
1078	<	return new VectorIterator(0);
1078	>	return new Itr();
1079		}
1080
1081		/**
1082	<	* A streamlined version of AbstractList.ListItr.
1082	>	* An optimized version of AbstractList.Itr
1083		*/
1084	<	private final class VectorIterator implements ListIterator<E> {
1085	<	int cursor;                // current position
1086	<	int lastRet;               // index of last returned element
1087	<	int expectedModCount;      // to check for CME
1076	<
1077	<	VectorIterator(int index) {
1078	<	cursor = index;
1079	<	expectedModCount = modCount;
1080	<	lastRet = -1;
1081	<	}
1084	>	private class Itr implements Iterator<E> {
1085	>	int cursor;       // index of next element to return
1086	>	int lastRet = -1; // index of last element returned; -1 if no such
1087	>	int expectedModCount = modCount;
1088
1089	<	public boolean hasNext() {
1089	>	public boolean hasNext() {
1090		// Racy but within spec, since modifications are checked
1091		// within or after synchronization in next/previous
1092		return cursor != elementCount;
1093	<	}
1088	<
1089	<	public boolean hasPrevious() {
1090	<	return cursor != 0;
1091	<	}
1092	<
1093	<	public int nextIndex() {
1094	<	return cursor;
1095	<	}
1096	<
1097	<	public int previousIndex() {
1098	<	return cursor - 1;
1099	<	}
1093	>	}
1094
1095	<	public E next() {
1096	<	try {
1095	>	public E next() {
1096	>	synchronized (Vector.this) {
1097	>	checkForComodification();
1098		int i = cursor;
1099	<	E next = get(i);
1100	<	lastRet = i;
1099	>	if (i >= elementCount)
1100	>	throw new NoSuchElementException();
1101		cursor = i + 1;
1102	<	return next;
1103	<	} catch (IndexOutOfBoundsException ex) {
1104	<	throw new NoSuchElementException();
1105	<	} finally {
1106	<	if (expectedModCount != modCount)
1107	<	throw new ConcurrentModificationException();
1102	>	return elementData(lastRet = i);
1103	>	}
1104	>	}
1105	>
1106	>	public void remove() {
1107	>	if (lastRet == -1)
1108	>	throw new IllegalStateException();
1109	>	synchronized (Vector.this) {
1110	>	checkForComodification();
1111	>	Vector.this.remove(lastRet);
1112	>	expectedModCount = modCount;
1113		}
1114	<	}
1114	>	cursor = lastRet;
1115	>	lastRet = -1;
1116	>	}
1117
1118	<	public E previous() {
1119	<	try {
1118	>	final void checkForComodification() {
1119	>	if (modCount != expectedModCount)
1120	>	throw new ConcurrentModificationException();
1121	>	}
1122	>	}
1123	>
1124	>	/**
1125	>	* An optimized version of AbstractList.ListItr
1126	>	*/
1127	>	final class ListItr extends Itr implements ListIterator<E> {
1128	>	ListItr(int index) {
1129	>	super();
1130	>	cursor = index;
1131	>	}
1132	>
1133	>	public boolean hasPrevious() {
1134	>	return cursor != 0;
1135	>	}
1136	>
1137	>	public int nextIndex() {
1138	>	return cursor;
1139	>	}
1140	>
1141	>	public int previousIndex() {
1142	>	return cursor - 1;
1143	>	}
1144	>
1145	>	public E previous() {
1146	>	synchronized (Vector.this) {
1147	>	checkForComodification();
1148		int i = cursor - 1;
1149	<	E prev = get(i);
1150	<	lastRet = i;
1149	>	if (i < 0)
1150	>	throw new NoSuchElementException();
1151		cursor = i;
1152	<	return prev;
1123	<	} catch (IndexOutOfBoundsException ex) {
1124	<	throw new NoSuchElementException();
1125	<	} finally {
1126	<	if (expectedModCount != modCount)
1127	<	throw new ConcurrentModificationException();
1152	>	return elementData(lastRet = i);
1153		}
1154		}
1155
1156	<	public void remove() {
1157	<	if (lastRet == -1)
1158	<	throw new IllegalStateException();
1159	<	if (expectedModCount != modCount)
1160	<	throw new ConcurrentModificationException();
1161	<	try {
1162	<	Vector.this.remove(lastRet);
1163	<	if (lastRet < cursor)
1139	<	cursor--;
1140	<	lastRet = -1;
1141	<	expectedModCount = modCount;
1142	<	} catch (IndexOutOfBoundsException ex) {
1143	<	throw new ConcurrentModificationException();
1144	<	}
1145	<	}
1146	<
1147	<	public void set(E e) {
1148	<	if (lastRet == -1)
1149	<	throw new IllegalStateException();
1150	<	if (expectedModCount != modCount)
1151	<	throw new ConcurrentModificationException();
1152	<	try {
1153	<	Vector.this.set(lastRet, e);
1154	<	expectedModCount = modCount;
1155	<	} catch (IndexOutOfBoundsException ex) {
1156	<	throw new ConcurrentModificationException();
1157	<	}
1158	<	}
1156	>	public void set(E e) {
1157	>	if (lastRet == -1)
1158	>	throw new IllegalStateException();
1159	>	synchronized (Vector.this) {
1160	>	checkForComodification();
1161	>	Vector.this.set(lastRet, e);
1162	>	}
1163	>	}
1164
1165	<	public void add(E e) {
1166	<	if (expectedModCount != modCount)
1167	<	throw new ConcurrentModificationException();
1168	<	try {
1169	<	int i = cursor;
1170	<	Vector.this.add(i, e);
1171	<	cursor = i + 1;
1172	<	lastRet = -1;
1173	<	expectedModCount = modCount;
1174	<	} catch (IndexOutOfBoundsException ex) {
1170	<	throw new ConcurrentModificationException();
1171	<	}
1172	<	}
1165	>	public void add(E e) {
1166	>	int i = cursor;
1167	>	synchronized (Vector.this) {
1168	>	checkForComodification();
1169	>	Vector.this.add(i, e);
1170	>	expectedModCount = modCount;
1171	>	}
1172	>	cursor = i + 1;
1173	>	lastRet = -1;
1174	>	}
1175		}
1176		}

Diff Legend

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