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.8 by jsr166, Tue Feb 7 20:54:24 2006 UTC vs.
Revision 1.33 by jsr166, Sun Nov 13 02:10:09 2016 UTC

#	Line 1 | Line 1
1		/*
2	<	* %W% %E%
2	>	* Copyright (c) 1994, 2013, Oracle and/or its affiliates. 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.  Oracle designates this
8	>	* particular file as subject to the "Classpath" exception as provided
9	>	* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22	>	* or visit www.oracle.com if you need additional information or have any
23	>	* questions.
24		*/
25
26		package java.util;
27
28	+	import java.util.function.Consumer;
29	+	import java.util.function.Predicate;
30	+	import java.util.function.UnaryOperator;
31	+
32		/**
33	<	* The <code>Vector</code> class implements a growable array of
33	>	* The {@code Vector} class implements a growable array of
34		* objects. Like an array, it contains components that can be
35		* accessed using an integer index. However, the size of a
36	<	* <code>Vector</code> can grow or shrink as needed to accommodate
37	<	* adding and removing items after the <code>Vector</code> has been created.<p>
36	>	* {@code Vector} can grow or shrink as needed to accommodate
37	>	* adding and removing items after the {@code Vector} has been created.
38		*
39	<	* Each vector tries to optimize storage management by maintaining a
40	<	* <code>capacity</code> and a <code>capacityIncrement</code>. The
41	<	* <code>capacity</code> is always at least as large as the vector
39	>	* <p>Each vector tries to optimize storage management by maintaining a
40	>	* {@code capacity} and a {@code capacityIncrement}. The
41	>	* {@code capacity} is always at least as large as the vector
42		* size; it is usually larger because as components are added to the
43		* vector, the vector's storage increases in chunks the size of
44	<	* <code>capacityIncrement</code>. An application can increase the
44	>	* {@code capacityIncrement}. An application can increase the
45		* capacity of a vector before inserting a large number of
46	<	* components; this reduces the amount of incremental reallocation. <p>
25	<	*
26	<	* As of the Java 2 platform v1.2, this class has been retrofitted to
27	<	* implement List, so that it becomes a part of Java's collection framework.
28	<	* Unlike the new collection implementations, Vector is synchronized.<p>
46	>	* components; this reduces the amount of incremental reallocation.
47		*
48	<	* The Iterators returned by Vector's iterator and listIterator
49	<	* methods are <em>fail-fast</em>: if the Vector is structurally modified
50	<	* at any time after the Iterator is created, in any way except through the
51	<	* Iterator's own remove or add methods, the Iterator will throw a
52	<	* ConcurrentModificationException.  Thus, in the face of concurrent
53	<	* modification, the Iterator fails quickly and cleanly, rather than risking
54	<	* arbitrary, non-deterministic behavior at an undetermined time in the future.
55	<	* The Enumerations returned by Vector's elements method are <em>not</em>
56	<	* fail-fast.
48	>	* <p id="fail-fast">
49	>	* The iterators returned by this class's {@link #iterator() iterator} and
50	>	* {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
51	>	* if the vector is structurally modified at any time after the iterator is
52	>	* created, in any way except through the iterator's own
53	>	* {@link ListIterator#remove() remove} or
54	>	* {@link ListIterator#add(Object) add} methods, the iterator will throw a
55	>	* {@link ConcurrentModificationException}.  Thus, in the face of
56	>	* concurrent modification, the iterator fails quickly and cleanly, rather
57	>	* than risking arbitrary, non-deterministic behavior at an undetermined
58	>	* time in the future.  The {@link Enumeration Enumerations} returned by
59	>	* the {@link #elements() elements} method are <em>not</em> fail-fast; if the
60	>	* Vector is structurally modified at any time after the enumeration is
61	>	* created then the results of enumerating are undefined.
62		*
63		* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
64		* as it is, generally speaking, impossible to make any hard guarantees in the
65		* presence of unsynchronized concurrent modification.  Fail-fast iterators
66	<	* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
66	>	* throw {@code ConcurrentModificationException} on a best-effort basis.
67		* Therefore, it would be wrong to write a program that depended on this
68		* exception for its correctness:  <i>the fail-fast behavior of iterators
69	<	* should be used only to detect bugs.</i><p>
69	>	* should be used only to detect bugs.</i>
70		*
71	<	* This class is a member of the
72	<	* <a href="{@docRoot}/../guide/collections/index.html">
73	<	* Java Collections Framework</a>.
71	>	* <p>As of the Java 2 platform v1.2, this class was retrofitted to
72	>	* implement the {@link List} interface, making it a member of the
73	>	* <a href="{@docRoot}/../technotes/guides/collections/index.html">
74	>	* Java Collections Framework</a>.  Unlike the new collection
75	>	* implementations, {@code Vector} is synchronized.  If a thread-safe
76	>	* implementation is not needed, it is recommended to use {@link
77	>	* ArrayList} in place of {@code Vector}.
78	>	*
79	>	* @param <E> Type of component elements
80		*
81		* @author  Lee Boynton
82		* @author  Jonathan Payne
54	–	* @version %I%, %G%
83		* @see Collection
56	–	* @see List
57	–	* @see ArrayList
84		* @see LinkedList
85	<	* @since   JDK1.0
85	>	* @since   1.0
86		*/
87		public class Vector<E>
88		extends AbstractList<E>
#	Line 65 | Line 91 | public class Vector<E>
91		/**
92		* The array buffer into which the components of the vector are
93		* stored. The capacity of the vector is the length of this array buffer,
94	<	* and is at least large enough to contain all the vector's elements.<p>
94	>	* and is at least large enough to contain all the vector's elements.
95		*
96	<	* Any array elements following the last element in the Vector are null.
96	>	* <p>Any array elements following the last element in the Vector are null.
97		*
98		* @serial
99		*/
100		protected Object[] elementData;
101
102		/**
103	<	* The number of valid components in this <tt>Vector</tt> object.
104	<	* Components <tt>elementData[0]</tt> through
105	<	* <tt>elementData[elementCount-1]</tt> are the actual items.
103	>	* The number of valid components in this {@code Vector} object.
104	>	* Components {@code elementData[0]} through
105	>	* {@code elementData[elementCount-1]} are the actual items.
106		*
107		* @serial
108		*/
#	Line 102 | Line 128 | public class Vector<E>
128		* @param   initialCapacity     the initial capacity of the vector
129		* @param   capacityIncrement   the amount by which the capacity is
130		*                              increased when the vector overflows
131	<	* @exception IllegalArgumentException if the specified initial capacity
132	<	*               is negative
131	>	* @throws IllegalArgumentException if the specified initial capacity
132	>	*         is negative
133		*/
134		public Vector(int initialCapacity, int capacityIncrement) {
135	<	super();
135	>	super();
136		if (initialCapacity < 0)
137		throw new IllegalArgumentException("Illegal Capacity: "+
138		initialCapacity);
139	<	this.elementData = new Object[initialCapacity];
140	<	this.capacityIncrement = capacityIncrement;
139	>	this.elementData = new Object[initialCapacity];
140	>	this.capacityIncrement = capacityIncrement;
141		}
142
143		/**
#	Line 119 | Line 145 | public class Vector<E>
145		* with its capacity increment equal to zero.
146		*
147		* @param   initialCapacity   the initial capacity of the vector
148	<	* @exception IllegalArgumentException if the specified initial capacity
149	<	*               is negative
148	>	* @throws IllegalArgumentException if the specified initial capacity
149	>	*         is negative
150		*/
151		public Vector(int initialCapacity) {
152	<	this(initialCapacity, 0);
152	>	this(initialCapacity, 0);
153		}
154
155		/**
156		* Constructs an empty vector so that its internal data array
157	<	* has size <tt>10</tt> and its standard capacity increment is
157	>	* has size {@code 10} and its standard capacity increment is
158		* zero.
159		*/
160		public Vector() {
161	<	this(10);
161	>	this(10);
162		}
163
164		/**
#	Line 146 | Line 172 | public class Vector<E>
172		* @since   1.2
173		*/
174		public Vector(Collection<? extends E> c) {
175	<	elementData = c.toArray();
176	<	elementCount = elementData.length;
177	<	// c.toArray might (incorrectly) not return Object[] (see 6260652)
178	<	if (elementData.getClass() != Object[].class)
179	<	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
175	>	elementData = c.toArray();
176	>	elementCount = elementData.length;
177	>	// defend against c.toArray (incorrectly) not returning Object[]
178	>	// (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
179	>	if (elementData.getClass() != Object[].class)
180	>	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
181		}
182
183		/**
184		* Copies the components of this vector into the specified array.
185	<	* The item at index <tt>k</tt> in this vector is copied into
186	<	* component <tt>k</tt> of <tt>anArray</tt>.
185	>	* The item at index {@code k} in this vector is copied into
186	>	* component {@code k} of {@code anArray}.
187		*
188		* @param  anArray the array into which the components get copied
189		* @throws NullPointerException if the given array is null
#	Line 167 | Line 194 | public class Vector<E>
194		* @see #toArray(Object[])
195		*/
196		public synchronized void copyInto(Object[] anArray) {
197	<	System.arraycopy(elementData, 0, anArray, 0, elementCount);
197	>	System.arraycopy(elementData, 0, anArray, 0, elementCount);
198		}
199
200		/**
201		* Trims the capacity of this vector to be the vector's current
202		* size. If the capacity of this vector is larger than its current
203		* size, then the capacity is changed to equal the size by replacing
204	<	* its internal data array, kept in the field <tt>elementData</tt>,
204	>	* its internal data array, kept in the field {@code elementData},
205		* with a smaller one. An application can use this operation to
206		* minimize the storage of a vector.
207		*/
208		public synchronized void trimToSize() {
209	<	modCount++;
210	<	int oldCapacity = elementData.length;
211	<	if (elementCount < oldCapacity) {
209	>	modCount++;
210	>	int oldCapacity = elementData.length;
211	>	if (elementCount < oldCapacity) {
212		elementData = Arrays.copyOf(elementData, elementCount);
213	<	}
213	>	}
214		}
215
216		/**
#	Line 192 | Line 219 | public class Vector<E>
219		* the minimum capacity argument.
220		*
221		* <p>If the current capacity of this vector is less than
222	<	* <tt>minCapacity</tt>, then its capacity is increased by replacing its
223	<	* internal data array, kept in the field <tt>elementData</tt>, with a
222	>	* {@code minCapacity}, then its capacity is increased by replacing its
223	>	* internal data array, kept in the field {@code elementData}, with a
224		* larger one.  The size of the new data array will be the old size plus
225	<	* <tt>capacityIncrement</tt>, unless the value of
226	<	* <tt>capacityIncrement</tt> is less than or equal to zero, in which case
225	>	* {@code capacityIncrement}, unless the value of
226	>	* {@code capacityIncrement} is less than or equal to zero, in which case
227		* the new capacity will be twice the old capacity; but if this new size
228	<	* is still smaller than <tt>minCapacity</tt>, then the new capacity will
229	<	* be <tt>minCapacity</tt>.
228	>	* is still smaller than {@code minCapacity}, then the new capacity will
229	>	* be {@code minCapacity}.
230		*
231		* @param minCapacity the desired minimum capacity
232		*/
233		public synchronized void ensureCapacity(int minCapacity) {
234	<	modCount++;
235	<	ensureCapacityHelper(minCapacity);
234	>	if (minCapacity > 0) {
235	>	modCount++;
236	>	if (minCapacity > elementData.length)
237	>	grow(minCapacity);
238	>	}
239	>	}
240	>
241	>	/**
242	>	* The maximum size of array to allocate (unless necessary).
243	>	* Some VMs reserve some header words in an array.
244	>	* Attempts to allocate larger arrays may result in
245	>	* OutOfMemoryError: Requested array size exceeds VM limit
246	>	*/
247	>	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
248	>
249	>	/**
250	>	* Increases the capacity to ensure that it can hold at least the
251	>	* number of elements specified by the minimum capacity argument.
252	>	*
253	>	* @param minCapacity the desired minimum capacity
254	>	* @throws OutOfMemoryError if minCapacity is less than zero
255	>	*/
256	>	private Object[] grow(int minCapacity) {
257	>	return elementData = Arrays.copyOf(elementData,
258	>	newCapacity(minCapacity));
259	>	}
260	>
261	>	private Object[] grow() {
262	>	return grow(elementCount + 1);
263		}
264
265		/**
266	<	* This implements the unsynchronized semantics of ensureCapacity.
267	<	* Synchronized methods in this class can internally call this
268	<	* method for ensuring capacity without incurring the cost of an
269	<	* extra synchronization.
270	<	*
271	<	* @see java.util.Vector#ensureCapacity(int)
272	<	*/
273	<	private void ensureCapacityHelper(int minCapacity) {
274	<	int oldCapacity = elementData.length;
275	<	if (minCapacity > oldCapacity) {
276	<	Object[] oldData = elementData;
277	<	int newCapacity = (capacityIncrement > 0) ?
278	<	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
279	<	if (newCapacity < minCapacity) {
280	<	newCapacity = minCapacity;
281	<	}
282	<	elementData = Arrays.copyOf(elementData, newCapacity);
283	<	}
266	>	* Returns a capacity at least as large as the given minimum capacity.
267	>	* Will not return a capacity greater than MAX_ARRAY_SIZE unless
268	>	* the given minimum capacity is greater than MAX_ARRAY_SIZE.
269	>	*
270	>	* @param minCapacity the desired minimum capacity
271	>	* @throws OutOfMemoryError if minCapacity is less than zero
272	>	*/
273	>	private int newCapacity(int minCapacity) {
274	>	// overflow-conscious code
275	>	int oldCapacity = elementData.length;
276	>	int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
277	>	capacityIncrement : oldCapacity);
278	>	if (newCapacity - minCapacity <= 0) {
279	>	if (minCapacity < 0) // overflow
280	>	throw new OutOfMemoryError();
281	>	return minCapacity;
282	>	}
283	>	return (newCapacity - MAX_ARRAY_SIZE <= 0)
284	>	? newCapacity
285	>	: hugeCapacity(minCapacity);
286	>	}
287	>
288	>	private static int hugeCapacity(int minCapacity) {
289	>	if (minCapacity < 0) // overflow
290	>	throw new OutOfMemoryError();
291	>	return (minCapacity > MAX_ARRAY_SIZE) ?
292	>	Integer.MAX_VALUE :
293	>	MAX_ARRAY_SIZE;
294		}
295
296		/**
297		* Sets the size of this vector. If the new size is greater than the
298	<	* current size, new <code>null</code> items are added to the end of
298	>	* current size, new {@code null} items are added to the end of
299		* the vector. If the new size is less than the current size, all
300	<	* components at index <code>newSize</code> and greater are discarded.
300	>	* components at index {@code newSize} and greater are discarded.
301		*
302	<	* @param   newSize   the new size of this vector
303	<	* @throws  ArrayIndexOutOfBoundsException if new size is negative
302	>	* @param  newSize   the new size of this vector
303	>	* @throws ArrayIndexOutOfBoundsException if the new size is negative
304		*/
305		public synchronized void setSize(int newSize) {
306	<	modCount++;
307	<	if (newSize > elementCount) {
308	<	ensureCapacityHelper(newSize);
309	<	} else {
310	<	for (int i = newSize ; i < elementCount ; i++) {
311	<	elementData[i] = null;
248	<	}
249	<	}
250	<	elementCount = newSize;
306	>	modCount++;
307	>	if (newSize > elementData.length)
308	>	grow(newSize);
309	>	for (int i = newSize; i < elementCount; i++)
310	>	elementData[i] = null;
311	>	elementCount = newSize;
312		}
313
314		/**
315		* Returns the current capacity of this vector.
316		*
317		* @return  the current capacity (the length of its internal
318	<	*          data array, kept in the field <tt>elementData</tt>
318	>	*          data array, kept in the field {@code elementData}
319		*          of this vector)
320		*/
321		public synchronized int capacity() {
322	<	return elementData.length;
322	>	return elementData.length;
323		}
324
325		/**
#	Line 267 | Line 328 | public class Vector<E>
328		* @return  the number of components in this vector
329		*/
330		public synchronized int size() {
331	<	return elementCount;
331	>	return elementCount;
332		}
333
334		/**
335		* Tests if this vector has no components.
336		*
337	<	* @return  <code>true</code> if and only if this vector has
337	>	* @return  {@code true} if and only if this vector has
338		*          no components, that is, its size is zero;
339	<	*          <code>false</code> otherwise.
339	>	*          {@code false} otherwise.
340		*/
341		public synchronized boolean isEmpty() {
342	<	return elementCount == 0;
342	>	return elementCount == 0;
343		}
344
345		/**
346		* Returns an enumeration of the components of this vector. The
347	<	* returned <tt>Enumeration</tt> object will generate all items in
348	<	* this vector. The first item generated is the item at index <tt>0</tt>,
349	<	* then the item at index <tt>1</tt>, and so on.
347	>	* returned {@code Enumeration} object will generate all items in
348	>	* this vector. The first item generated is the item at index {@code 0},
349	>	* then the item at index {@code 1}, and so on. If the vector is
350	>	* structurally modified while enumerating over the elements then the
351	>	* results of enumerating are undefined.
352		*
353		* @return  an enumeration of the components of this vector
291	–	* @see     Enumeration
354		* @see     Iterator
355		*/
356		public Enumeration<E> elements() {
357	<	return new Enumeration<E>() {
358	<	int count = 0;
357	>	return new Enumeration<E>() {
358	>	int count = 0;
359	>
360	>	public boolean hasMoreElements() {
361	>	return count < elementCount;
362	>	}
363
364	<	public boolean hasMoreElements() {
365	<	return count < elementCount;
366	<	}
367	<
368	<	public E nextElement() {
369	<	synchronized (Vector.this) {
370	<	if (count < elementCount) {
371	<	return (E)elementData[count++];
372	<	}
307	<	}
308	<	throw new NoSuchElementException("Vector Enumeration");
309	<	}
310	<	};
364	>	public E nextElement() {
365	>	synchronized (Vector.this) {
366	>	if (count < elementCount) {
367	>	return elementData(count++);
368	>	}
369	>	}
370	>	throw new NoSuchElementException("Vector Enumeration");
371	>	}
372	>	};
373		}
374
375		/**
376	<	* Returns <tt>true</tt> if this vector contains the specified element.
377	<	* More formally, returns <tt>true</tt> if and only if this vector
378	<	* contains at least one element <tt>e</tt> such that
379	<	* <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
376	>	* Returns {@code true} if this vector contains the specified element.
377	>	* More formally, returns {@code true} if and only if this vector
378	>	* contains at least one element {@code e} such that
379	>	* {@code Objects.equals(o, e)}.
380		*
381		* @param o element whose presence in this vector is to be tested
382	<	* @return <tt>true</tt> if this vector contains the specified element
382	>	* @return {@code true} if this vector contains the specified element
383		*/
384		public boolean contains(Object o) {
385	<	return indexOf(o, 0) >= 0;
385	>	return indexOf(o, 0) >= 0;
386		}
387
388		/**
389		* Returns the index of the first occurrence of the specified element
390		* in this vector, or -1 if this vector does not contain the element.
391	<	* More formally, returns the lowest index <tt>i</tt> such that
392	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
391	>	* More formally, returns the lowest index {@code i} such that
392	>	* {@code Objects.equals(o, get(i))},
393		* or -1 if there is no such index.
394		*
395		* @param o element to search for
#	Line 335 | Line 397 | public class Vector<E>
397		*         this vector, or -1 if this vector does not contain the element
398		*/
399		public int indexOf(Object o) {
400	<	return indexOf(o, 0);
400	>	return indexOf(o, 0);
401		}
402
403		/**
404		* Returns the index of the first occurrence of the specified element in
405	<	* this vector, searching forwards from <tt>index</tt>, or returns -1 if
405	>	* this vector, searching forwards from {@code index}, or returns -1 if
406		* the element is not found.
407	<	* More formally, returns the lowest index <tt>i</tt> such that
408	<	* <tt>(i&nbsp;&gt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
407	>	* More formally, returns the lowest index {@code i} such that
408	>	* {@code (i >= index && Objects.equals(o, get(i)))},
409		* or -1 if there is no such index.
410		*
411		* @param o element to search for
412		* @param index index to start searching from
413		* @return the index of the first occurrence of the element in
414	<	*         this vector at position <tt>index</tt> or later in the vector;
415	<	*         <tt>-1</tt> if the element is not found.
414	>	*         this vector at position {@code index} or later in the vector;
415	>	*         {@code -1} if the element is not found.
416		* @throws IndexOutOfBoundsException if the specified index is negative
417		* @see     Object#equals(Object)
418		*/
419		public synchronized int indexOf(Object o, int index) {
420	<	if (o == null) {
421	<	for (int i = index ; i < elementCount ; i++)
422	<	if (elementData[i]==null)
423	<	return i;
424	<	} else {
425	<	for (int i = index ; i < elementCount ; i++)
426	<	if (o.equals(elementData[i]))
427	<	return i;
428	<	}
429	<	return -1;
420	>	if (o == null) {
421	>	for (int i = index ; i < elementCount ; i++)
422	>	if (elementData[i]==null)
423	>	return i;
424	>	} else {
425	>	for (int i = index ; i < elementCount ; i++)
426	>	if (o.equals(elementData[i]))
427	>	return i;
428	>	}
429	>	return -1;
430		}
431
432		/**
433		* Returns the index of the last occurrence of the specified element
434		* in this vector, or -1 if this vector does not contain the element.
435	<	* More formally, returns the highest index <tt>i</tt> such that
436	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
435	>	* More formally, returns the highest index {@code i} such that
436	>	* {@code Objects.equals(o, get(i))},
437		* or -1 if there is no such index.
438		*
439		* @param o element to search for
#	Line 379 | Line 441 | public class Vector<E>
441		*         this vector, or -1 if this vector does not contain the element
442		*/
443		public synchronized int lastIndexOf(Object o) {
444	<	return lastIndexOf(o, elementCount-1);
444	>	return lastIndexOf(o, elementCount-1);
445		}
446
447		/**
448		* Returns the index of the last occurrence of the specified element in
449	<	* this vector, searching backwards from <tt>index</tt>, or returns -1 if
449	>	* this vector, searching backwards from {@code index}, or returns -1 if
450		* the element is not found.
451	<	* More formally, returns the highest index <tt>i</tt> such that
452	<	* <tt>(i&nbsp;&lt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
451	>	* More formally, returns the highest index {@code i} such that
452	>	* {@code (i <= index && Objects.equals(o, get(i)))},
453		* or -1 if there is no such index.
454		*
455		* @param o element to search for
456		* @param index index to start searching backwards from
457		* @return the index of the last occurrence of the element at position
458	<	*         less than or equal to <tt>index</tt> in this vector;
458	>	*         less than or equal to {@code index} in this vector;
459		*         -1 if the element is not found.
460		* @throws IndexOutOfBoundsException if the specified index is greater
461		*         than or equal to the current size of this vector
#	Line 402 | Line 464 | public class Vector<E>
464		if (index >= elementCount)
465		throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
466
467	<	if (o == null) {
468	<	for (int i = index; i >= 0; i--)
469	<	if (elementData[i]==null)
470	<	return i;
471	<	} else {
472	<	for (int i = index; i >= 0; i--)
473	<	if (o.equals(elementData[i]))
474	<	return i;
475	<	}
476	<	return -1;
467	>	if (o == null) {
468	>	for (int i = index; i >= 0; i--)
469	>	if (elementData[i]==null)
470	>	return i;
471	>	} else {
472	>	for (int i = index; i >= 0; i--)
473	>	if (o.equals(elementData[i]))
474	>	return i;
475	>	}
476	>	return -1;
477		}
478
479		/**
480	<	* Returns the component at the specified index.<p>
480	>	* Returns the component at the specified index.
481		*
482	<	* This method is identical in functionality to the get method
483	<	* (which is part of the List interface).
482	>	* <p>This method is identical in functionality to the {@link #get(int)}
483	>	* method (which is part of the {@link List} interface).
484		*
485		* @param      index   an index into this vector
486		* @return     the component at the specified index
487	<	* @exception  ArrayIndexOutOfBoundsException  if the <tt>index</tt>
488	<	*             is negative or not less than the current size of this
427	<	*             <tt>Vector</tt> object.
428	<	* @see        #get(int)
429	<	* @see        List
487	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
488	>	*         ({@code index < 0 || index >= size()})
489		*/
490		public synchronized E elementAt(int index) {
491	<	if (index >= elementCount) {
492	<	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
493	<	}
491	>	if (index >= elementCount) {
492	>	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
493	>	}
494
495	<	return (E)elementData[index];
495	>	return elementData(index);
496		}
497
498		/**
499	<	* Returns the first component (the item at index <tt>0</tt>) of
499	>	* Returns the first component (the item at index {@code 0}) of
500		* this vector.
501		*
502		* @return     the first component of this vector
503	<	* @exception  NoSuchElementException  if this vector has no components
503	>	* @throws NoSuchElementException if this vector has no components
504		*/
505		public synchronized E firstElement() {
506	<	if (elementCount == 0) {
507	<	throw new NoSuchElementException();
508	<	}
509	<	return (E)elementData[0];
506	>	if (elementCount == 0) {
507	>	throw new NoSuchElementException();
508	>	}
509	>	return elementData(0);
510		}
511
512		/**
513		* Returns the last component of the vector.
514		*
515		* @return  the last component of the vector, i.e., the component at index
516	<	*          <code>size()&nbsp;-&nbsp;1</code>.
517	<	* @exception  NoSuchElementException  if this vector is empty
516	>	*          {@code size() - 1}
517	>	* @throws NoSuchElementException if this vector is empty
518		*/
519		public synchronized E lastElement() {
520	<	if (elementCount == 0) {
521	<	throw new NoSuchElementException();
522	<	}
523	<	return (E)elementData[elementCount - 1];
520	>	if (elementCount == 0) {
521	>	throw new NoSuchElementException();
522	>	}
523	>	return elementData(elementCount - 1);
524		}
525
526		/**
527	<	* Sets the component at the specified <code>index</code> of this
527	>	* Sets the component at the specified {@code index} of this
528		* vector to be the specified object. The previous component at that
529	<	* position is discarded.<p>
529	>	* position is discarded.
530		*
531	<	* The index must be a value greater than or equal to <code>0</code>
532	<	* and less than the current size of the vector. <p>
531	>	* <p>The index must be a value greater than or equal to {@code 0}
532	>	* and less than the current size of the vector.
533		*
534	<	* This method is identical in functionality to the set method
535	<	* (which is part of the List interface). Note that the set method reverses
536	<	* the order of the parameters, to more closely match array usage.  Note
537	<	* also that the set method returns the old value that was stored at the
538	<	* specified position.
534	>	* <p>This method is identical in functionality to the
535	>	* {@link #set(int, Object) set(int, E)}
536	>	* method (which is part of the {@link List} interface). Note that the
537	>	* {@code set} method reverses the order of the parameters, to more closely
538	>	* match array usage.  Note also that the {@code set} method returns the
539	>	* old value that was stored at the specified position.
540		*
541		* @param      obj     what the component is to be set to
542		* @param      index   the specified index
543	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
544	<	* @see        #size()
485	<	* @see        List
486	<	* @see        #set(int, java.lang.Object)
543	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
544	>	*         ({@code index < 0 || index >= size()})
545		*/
546		public synchronized void setElementAt(E obj, int index) {
547	<	if (index >= elementCount) {
548	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
549	<	elementCount);
550	<	}
551	<	elementData[index] = obj;
547	>	if (index >= elementCount) {
548	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
549	>	elementCount);
550	>	}
551	>	elementData[index] = obj;
552		}
553
554		/**
555		* Deletes the component at the specified index. Each component in
556		* this vector with an index greater or equal to the specified
557	<	* <code>index</code> is shifted downward to have an index one
557	>	* {@code index} is shifted downward to have an index one
558		* smaller than the value it had previously. The size of this vector
559	<	* is decreased by <tt>1</tt>.<p>
559	>	* is decreased by {@code 1}.
560		*
561	<	* The index must be a value greater than or equal to <code>0</code>
562	<	* and less than the current size of the vector. <p>
561	>	* <p>The index must be a value greater than or equal to {@code 0}
562	>	* and less than the current size of the vector.
563		*
564	<	* This method is identical in functionality to the remove method
565	<	* (which is part of the List interface).  Note that the remove method
566	<	* returns the old value that was stored at the specified position.
564	>	* <p>This method is identical in functionality to the {@link #remove(int)}
565	>	* method (which is part of the {@link List} interface).  Note that the
566	>	* {@code remove} method returns the old value that was stored at the
567	>	* specified position.
568		*
569		* @param      index   the index of the object to remove
570	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
571	<	* @see        #size()
513	<	* @see        #remove(int)
514	<	* @see        List
570	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
571	>	*         ({@code index < 0 || index >= size()})
572		*/
573		public synchronized void removeElementAt(int index) {
574	<	modCount++;
575	<	if (index >= elementCount) {
576	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
577	<	elementCount);
578	<	}
579	<	else if (index < 0) {
580	<	throw new ArrayIndexOutOfBoundsException(index);
581	<	}
582	<	int j = elementCount - index - 1;
583	<	if (j > 0) {
584	<	System.arraycopy(elementData, index + 1, elementData, index, j);
585	<	}
586	<	elementCount--;
587	<	elementData[elementCount] = null; /* to let gc do its work */
574	>	if (index >= elementCount) {
575	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
576	>	elementCount);
577	>	}
578	>	else if (index < 0) {
579	>	throw new ArrayIndexOutOfBoundsException(index);
580	>	}
581	>	int j = elementCount - index - 1;
582	>	if (j > 0) {
583	>	System.arraycopy(elementData, index + 1, elementData, index, j);
584	>	}
585	>	modCount++;
586	>	elementCount--;
587	>	elementData[elementCount] = null; /* to let gc do its work */
588		}
589
590		/**
591		* Inserts the specified object as a component in this vector at the
592	<	* specified <code>index</code>. Each component in this vector with
593	<	* an index greater or equal to the specified <code>index</code> is
592	>	* specified {@code index}. Each component in this vector with
593	>	* an index greater or equal to the specified {@code index} is
594		* shifted upward to have an index one greater than the value it had
595	<	* previously. <p>
595	>	* previously.
596		*
597	<	* The index must be a value greater than or equal to <code>0</code>
597	>	* <p>The index must be a value greater than or equal to {@code 0}
598		* and less than or equal to the current size of the vector. (If the
599		* index is equal to the current size of the vector, the new element
600	<	* is appended to the Vector.)<p>
600	>	* is appended to the Vector.)
601		*
602	<	* This method is identical in functionality to the add(Object, int) method
603	<	* (which is part of the List interface). Note that the add method reverses
604	<	* the order of the parameters, to more closely match array usage.
602	>	* <p>This method is identical in functionality to the
603	>	* {@link #add(int, Object) add(int, E)}
604	>	* method (which is part of the {@link List} interface).  Note that the
605	>	* {@code add} method reverses the order of the parameters, to more closely
606	>	* match array usage.
607		*
608		* @param      obj     the component to insert
609		* @param      index   where to insert the new component
610	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
611	<	* @see        #size()
553	<	* @see        #add(int, Object)
554	<	* @see        List
610	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
611	>	*         ({@code index < 0 || index > size()})
612		*/
613		public synchronized void insertElementAt(E obj, int index) {
614	<	modCount++;
615	<	if (index > elementCount) {
616	<	throw new ArrayIndexOutOfBoundsException(index
617	<	+ " > " + elementCount);
618	<	}
619	<	ensureCapacityHelper(elementCount + 1);
620	<	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
621	<	elementData[index] = obj;
622	<	elementCount++;
614	>	if (index > elementCount) {
615	>	throw new ArrayIndexOutOfBoundsException(index
616	>	+ " > " + elementCount);
617	>	}
618	>	modCount++;
619	>	final int s = elementCount;
620	>	Object[] elementData = this.elementData;
621	>	if (s == elementData.length)
622	>	elementData = grow();
623	>	System.arraycopy(elementData, index,
624	>	elementData, index + 1,
625	>	s - index);
626	>	elementData[index] = obj;
627	>	elementCount = s + 1;
628		}
629
630		/**
631		* Adds the specified component to the end of this vector,
632		* increasing its size by one. The capacity of this vector is
633	<	* increased if its size becomes greater than its capacity. <p>
633	>	* increased if its size becomes greater than its capacity.
634		*
635	<	* This method is identical in functionality to the add(Object) method
636	<	* (which is part of the List interface).
635	>	* <p>This method is identical in functionality to the
636	>	* {@link #add(Object) add(E)}
637	>	* method (which is part of the {@link List} interface).
638		*
639		* @param   obj   the component to be added
577	–	* @see        #add(Object)
578	–	* @see        List
640		*/
641		public synchronized void addElement(E obj) {
642	<	modCount++;
643	<	ensureCapacityHelper(elementCount + 1);
583	<	elementData[elementCount++] = obj;
642	>	modCount++;
643	>	add(obj, elementData, elementCount);
644		}
645
646		/**
#	Line 588 | Line 648 | public class Vector<E>
648		* from this vector. If the object is found in this vector, each
649		* component in the vector with an index greater or equal to the
650		* object's index is shifted downward to have an index one smaller
651	<	* than the value it had previously.<p>
651	>	* than the value it had previously.
652		*
653	<	* This method is identical in functionality to the remove(Object)
654	<	* method (which is part of the List interface).
653	>	* <p>This method is identical in functionality to the
654	>	* {@link #remove(Object)} method (which is part of the
655	>	* {@link List} interface).
656		*
657		* @param   obj   the component to be removed
658	<	* @return  <code>true</code> if the argument was a component of this
659	<	*          vector; <code>false</code> otherwise.
599	<	* @see     List#remove(Object)
600	<	* @see     List
658	>	* @return  {@code true} if the argument was a component of this
659	>	*          vector; {@code false} otherwise.
660		*/
661		public synchronized boolean removeElement(Object obj) {
662	<	modCount++;
663	<	int i = indexOf(obj);
664	<	if (i >= 0) {
665	<	removeElementAt(i);
666	<	return true;
667	<	}
668	<	return false;
662	>	modCount++;
663	>	int i = indexOf(obj);
664	>	if (i >= 0) {
665	>	removeElementAt(i);
666	>	return true;
667	>	}
668	>	return false;
669		}
670
671		/**
672	<	* Removes all components from this vector and sets its size to zero.<p>
614	<	*
615	<	* This method is identical in functionality to the clear method
616	<	* (which is part of the List interface).
672	>	* Removes all components from this vector and sets its size to zero.
673		*
674	<	* @see     #clear
675	<	* @see     List
674	>	* <p>This method is identical in functionality to the {@link #clear}
675	>	* method (which is part of the {@link List} interface).
676		*/
677		public synchronized void removeAllElements() {
678	<	modCount++;
679	<	// Let gc do its work
680	<	for (int i = 0; i < elementCount; i++)
625	<	elementData[i] = null;
678	>	// Let gc do its work
679	>	for (int i = 0; i < elementCount; i++)
680	>	elementData[i] = null;
681
682	<	elementCount = 0;
682	>	modCount++;
683	>	elementCount = 0;
684		}
685
686		/**
687		* Returns a clone of this vector. The copy will contain a
688		* reference to a clone of the internal data array, not a reference
689	<	* to the original internal data array of this <tt>Vector</tt> object.
689	>	* to the original internal data array of this {@code Vector} object.
690		*
691		* @return  a clone of this vector
692		*/
693		public synchronized Object clone() {
694	<	try {
695	<	Vector<E> v = (Vector<E>) super.clone();
696	<	v.elementData = Arrays.copyOf(elementData, elementCount);
697	<	v.modCount = 0;
698	<	return v;
699	<	} catch (CloneNotSupportedException e) {
700	<	// this shouldn't happen, since we are Cloneable
701	<	throw new InternalError();
702	<	}
694	>	try {
695	>	@SuppressWarnings("unchecked")
696	>	Vector<E> v = (Vector<E>) super.clone();
697	>	v.elementData = Arrays.copyOf(elementData, elementCount);
698	>	v.modCount = 0;
699	>	return v;
700	>	} catch (CloneNotSupportedException e) {
701	>	// this shouldn't happen, since we are Cloneable
702	>	throw new InternalError(e);
703	>	}
704		}
705
706		/**
#	Line 661 | Line 718 | public class Vector<E>
718		* correct order; the runtime type of the returned array is that of the
719		* specified array.  If the Vector fits in the specified array, it is
720		* returned therein.  Otherwise, a new array is allocated with the runtime
721	<	* type of the specified array and the size of this Vector.<p>
721	>	* type of the specified array and the size of this Vector.
722		*
723	<	* If the Vector fits in the specified array with room to spare
723	>	* <p>If the Vector fits in the specified array with room to spare
724		* (i.e., the array has more elements than the Vector),
725		* the element in the array immediately following the end of the
726		* Vector is set to null.  (This is useful in determining the length
727		* of the Vector <em>only</em> if the caller knows that the Vector
728		* does not contain any null elements.)
729		*
730	+	* @param <T> type of array elements. The same type as {@code <E>} or a
731	+	* supertype of {@code <E>}.
732		* @param a the array into which the elements of the Vector are to
733	<	*          be stored, if it is big enough; otherwise, a new array of the
734	<	*          same runtime type is allocated for this purpose.
733	>	*          be stored, if it is big enough; otherwise, a new array of the
734	>	*          same runtime type is allocated for this purpose.
735		* @return an array containing the elements of the Vector
736	<	* @exception ArrayStoreException the runtime type of a is not a supertype
737	<	* of the runtime type of every element in this Vector
736	>	* @throws ArrayStoreException if the runtime type of a, {@code <T>}, is not
737	>	* a supertype of the runtime type, {@code <E>}, of every element in this
738	>	* Vector
739		* @throws NullPointerException if the given array is null
740		* @since 1.2
741		*/
742	+	@SuppressWarnings("unchecked")
743		public synchronized <T> T[] toArray(T[] a) {
744		if (a.length < elementCount)
745		return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
746
747	<	System.arraycopy(elementData, 0, a, 0, elementCount);
747	>	System.arraycopy(elementData, 0, a, 0, elementCount);
748
749		if (a.length > elementCount)
750		a[elementCount] = null;
#	Line 693 | Line 754 | public class Vector<E>
754
755		// Positional Access Operations
756
757	+	@SuppressWarnings("unchecked")
758	+	E elementData(int index) {
759	+	return (E) elementData[index];
760	+	}
761	+
762	+	@SuppressWarnings("unchecked")
763	+	static <E> E elementAt(Object[] es, int index) {
764	+	return (E) es[index];
765	+	}
766	+
767		/**
768		* Returns the element at the specified position in this Vector.
769		*
770		* @param index index of the element to return
771		* @return object at the specified index
772	<	* @exception ArrayIndexOutOfBoundsException index is out of range (index
773	<	*            &lt; 0 || index &gt;= size())
772	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
773	>	*            ({@code index < 0 || index >= size()})
774		* @since 1.2
775		*/
776		public synchronized E get(int index) {
777	<	if (index >= elementCount)
778	<	throw new ArrayIndexOutOfBoundsException(index);
777	>	if (index >= elementCount)
778	>	throw new ArrayIndexOutOfBoundsException(index);
779
780	<	return (E)elementData[index];
780	>	return elementData(index);
781		}
782
783		/**
#	Line 716 | Line 787 | public class Vector<E>
787		* @param index index of the element to replace
788		* @param element element to be stored at the specified position
789		* @return the element previously at the specified position
790	<	* @exception ArrayIndexOutOfBoundsException index out of range
791	<	*            (index &lt; 0 || index &gt;= size())
790	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
791	>	*         ({@code index < 0 || index >= size()})
792		* @since 1.2
793		*/
794		public synchronized E set(int index, E element) {
795	<	if (index >= elementCount)
796	<	throw new ArrayIndexOutOfBoundsException(index);
795	>	if (index >= elementCount)
796	>	throw new ArrayIndexOutOfBoundsException(index);
797
798	<	Object oldValue = elementData[index];
799	<	elementData[index] = element;
800	<	return (E)oldValue;
798	>	E oldValue = elementData(index);
799	>	elementData[index] = element;
800	>	return oldValue;
801	>	}
802	>
803	>	/**
804	>	* This helper method split out from add(E) to keep method
805	>	* bytecode size under 35 (the -XX:MaxInlineSize default value),
806	>	* which helps when add(E) is called in a C1-compiled loop.
807	>	*/
808	>	private void add(E e, Object[] elementData, int s) {
809	>	if (s == elementData.length)
810	>	elementData = grow();
811	>	elementData[s] = e;
812	>	elementCount = s + 1;
813		}
814
815		/**
816		* Appends the specified element to the end of this Vector.
817		*
818		* @param e element to be appended to this Vector
819	<	* @return <tt>true</tt> (as specified by {@link Collection#add})
819	>	* @return {@code true} (as specified by {@link Collection#add})
820		* @since 1.2
821		*/
822		public synchronized boolean add(E e) {
823	<	modCount++;
824	<	ensureCapacityHelper(elementCount + 1);
742	<	elementData[elementCount++] = e;
823	>	modCount++;
824	>	add(e, elementData, elementCount);
825		return true;
826		}
827
#	Line 747 | Line 829 | public class Vector<E>
829		* Removes the first occurrence of the specified element in this Vector
830		* If the Vector does not contain the element, it is unchanged.  More
831		* formally, removes the element with the lowest index i such that
832	<	* <code>(o==null ? get(i)==null : o.equals(get(i)))</code> (if such
832	>	* {@code Objects.equals(o, get(i))} (if such
833		* an element exists).
834		*
835		* @param o element to be removed from this Vector, if present
#	Line 765 | Line 847 | public class Vector<E>
847		*
848		* @param index index at which the specified element is to be inserted
849		* @param element element to be inserted
850	<	* @exception ArrayIndexOutOfBoundsException index is out of range
851	<	*            (index &lt; 0 || index &gt; size())
850	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
851	>	*         ({@code index < 0 || index > size()})
852		* @since 1.2
853		*/
854		public void add(int index, E element) {
#	Line 778 | Line 860 | public class Vector<E>
860		* Shifts any subsequent elements to the left (subtracts one from their
861		* indices).  Returns the element that was removed from the Vector.
862		*
781	–	* @exception ArrayIndexOutOfBoundsException index out of range (index
782	–	*            &lt; 0 || index &gt;= size())
863		* @param index the index of the element to be removed
864		* @return element that was removed
865	+	* @throws ArrayIndexOutOfBoundsException if the index is out of range
866	+	*         ({@code index < 0 || index >= size()})
867		* @since 1.2
868		*/
869		public synchronized E remove(int index) {
870	<	modCount++;
871	<	if (index >= elementCount)
872	<	throw new ArrayIndexOutOfBoundsException(index);
873	<	Object oldValue = elementData[index];
792	<
793	<	int numMoved = elementCount - index - 1;
794	<	if (numMoved > 0)
795	<	System.arraycopy(elementData, index+1, elementData, index,
796	<	numMoved);
797	<	elementData[--elementCount] = null; // Let gc do its work
870	>	modCount++;
871	>	if (index >= elementCount)
872	>	throw new ArrayIndexOutOfBoundsException(index);
873	>	E oldValue = elementData(index);
874
875	<	return (E)oldValue;
875	>	int numMoved = elementCount - index - 1;
876	>	if (numMoved > 0)
877	>	System.arraycopy(elementData, index+1, elementData, index,
878	>	numMoved);
879	>	elementData[--elementCount] = null; // Let gc do its work
880	>
881	>	return oldValue;
882		}
883
884		/**
#	Line 818 | Line 900 | public class Vector<E>
900		* @param   c a collection whose elements will be tested for containment
901		*          in this Vector
902		* @return true if this Vector contains all of the elements in the
903	<	*         specified collection
903	>	*         specified collection
904		* @throws NullPointerException if the specified collection is null
905		*/
906		public synchronized boolean containsAll(Collection<?> c) {
#	Line 834 | Line 916 | public class Vector<E>
916		* specified Collection is this Vector, and this Vector is nonempty.)
917		*
918		* @param c elements to be inserted into this Vector
919	<	* @return <tt>true</tt> if this Vector changed as a result of the call
919	>	* @return {@code true} if this Vector changed as a result of the call
920		* @throws NullPointerException if the specified collection is null
921		* @since 1.2
922		*/
923	<	public synchronized boolean addAll(Collection<? extends E> c) {
842	<	modCount++;
923	>	public boolean addAll(Collection<? extends E> c) {
924		Object[] a = c.toArray();
925	+	modCount++;
926		int numNew = a.length;
927	<	ensureCapacityHelper(elementCount + numNew);
928	<	System.arraycopy(a, 0, elementData, elementCount, numNew);
929	<	elementCount += numNew;
930	<	return numNew != 0;
927	>	if (numNew == 0)
928	>	return false;
929	>	synchronized (this) {
930	>	Object[] elementData = this.elementData;
931	>	final int s = elementCount;
932	>	if (numNew > elementData.length - s)
933	>	elementData = grow(s + numNew);
934	>	System.arraycopy(a, 0, elementData, s, numNew);
935	>	elementCount = s + numNew;
936	>	return true;
937	>	}
938		}
939
940		/**
#	Line 856 | Line 945 | public class Vector<E>
945		* @return true if this Vector changed as a result of the call
946		* @throws ClassCastException if the types of one or more elements
947		*         in this vector are incompatible with the specified
948	<	*         collection (optional)
948	>	*         collection
949	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
950		* @throws NullPointerException if this vector contains one or more null
951		*         elements and the specified collection does not support null
952	<	*         elements (optional), or if the specified collection is null
952	>	*         elements
953	>	* (<a href="Collection.html#optional-restrictions">optional</a>),
954	>	*         or if the specified collection is null
955		* @since 1.2
956		*/
957	<	public synchronized boolean removeAll(Collection<?> c) {
958	<	return super.removeAll(c);
957	>	public boolean removeAll(Collection<?> c) {
958	>	Objects.requireNonNull(c);
959	>	return bulkRemove(e -> c.contains(e));
960		}
961
962		/**
#	Line 876 | Line 969 | public class Vector<E>
969		* @return true if this Vector changed as a result of the call
970		* @throws ClassCastException if the types of one or more elements
971		*         in this vector are incompatible with the specified
972	<	*         collection (optional)
972	>	*         collection
973	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
974		* @throws NullPointerException if this vector contains one or more null
975		*         elements and the specified collection does not support null
976	<	*         elements (optional), or if the specified collection is null
976	>	*         elements
977	>	*         (<a href="Collection.html#optional-restrictions">optional</a>),
978	>	*         or if the specified collection is null
979		* @since 1.2
980		*/
981	<	public synchronized boolean retainAll(Collection<?> c)  {
982	<	return super.retainAll(c);
981	>	public boolean retainAll(Collection<?> c) {
982	>	Objects.requireNonNull(c);
983	>	return bulkRemove(e -> !c.contains(e));
984	>	}
985	>
986	>	@Override
987	>	public boolean removeIf(Predicate<? super E> filter) {
988	>	Objects.requireNonNull(filter);
989	>	return bulkRemove(filter);
990	>	}
991	>
992	>	// A tiny bit set implementation
993	>
994	>	private static long[] nBits(int n) {
995	>	return new long[((n - 1) >> 6) + 1];
996	>	}
997	>	private static void setBit(long[] bits, int i) {
998	>	bits[i >> 6] |= 1L << i;
999	>	}
1000	>	private static boolean isClear(long[] bits, int i) {
1001	>	return (bits[i >> 6] & (1L << i)) == 0;
1002	>	}
1003	>
1004	>	private synchronized boolean bulkRemove(Predicate<? super E> filter) {
1005	>	int expectedModCount = modCount;
1006	>	final Object[] es = elementData;
1007	>	final int end = elementCount;
1008	>	final boolean modified;
1009	>	int i;
1010	>	// Optimize for initial run of survivors
1011	>	for (i = 0; i < end && !filter.test(elementAt(es, i)); i++)
1012	>	;
1013	>	// Tolerate predicates that reentrantly access the collection for
1014	>	// read (but writers still get CME), so traverse once to find
1015	>	// elements to delete, a second pass to physically expunge.
1016	>	if (modified = (i < end)) {
1017	>	expectedModCount++;
1018	>	modCount++;
1019	>	final int beg = i;
1020	>	final long[] deathRow = nBits(end - beg);
1021	>	deathRow[0] = 1L;   // set bit 0
1022	>	for (i = beg + 1; i < end; i++)
1023	>	if (filter.test(elementAt(es, i)))
1024	>	setBit(deathRow, i - beg);
1025	>	int w = beg;
1026	>	for (i = beg; i < end; i++)
1027	>	if (isClear(deathRow, i - beg))
1028	>	es[w++] = es[i];
1029	>	Arrays.fill(es, elementCount = w, end, null);
1030	>	}
1031	>	if (modCount != expectedModCount)
1032	>	throw new ConcurrentModificationException();
1033	>	return modified;
1034		}
1035
1036		/**
#	Line 897 | Line 1044 | public class Vector<E>
1044		* @param index index at which to insert the first element from the
1045		*              specified collection
1046		* @param c elements to be inserted into this Vector
1047	<	* @return <tt>true</tt> if this Vector changed as a result of the call
1048	<	* @exception ArrayIndexOutOfBoundsException index out of range (index
1049	<	*            &lt; 0 || index &gt; size())
1047	>	* @return {@code true} if this Vector changed as a result of the call
1048	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
1049	>	*         ({@code index < 0 || index > size()})
1050		* @throws NullPointerException if the specified collection is null
1051		* @since 1.2
1052		*/
1053		public synchronized boolean addAll(int index, Collection<? extends E> c) {
1054	<	modCount++;
1055	<	if (index < 0 || index > elementCount)
909	<	throw new ArrayIndexOutOfBoundsException(index);
1054	>	if (index < 0 || index > elementCount)
1055	>	throw new ArrayIndexOutOfBoundsException(index);
1056
1057		Object[] a = c.toArray();
1058	<	int numNew = a.length;
1059	<	ensureCapacityHelper(elementCount + numNew);
1060	<
1061	<	int numMoved = elementCount - index;
1062	<	if (numMoved > 0)
1063	<	System.arraycopy(elementData, index, elementData, index + numNew,
1064	<	numMoved);
1065	<
1058	>	modCount++;
1059	>	int numNew = a.length;
1060	>	if (numNew == 0)
1061	>	return false;
1062	>	Object[] elementData = this.elementData;
1063	>	final int s = elementCount;
1064	>	if (numNew > elementData.length - s)
1065	>	elementData = grow(s + numNew);
1066	>
1067	>	int numMoved = s - index;
1068	>	if (numMoved > 0)
1069	>	System.arraycopy(elementData, index,
1070	>	elementData, index + numNew,
1071	>	numMoved);
1072		System.arraycopy(a, 0, elementData, index, numNew);
1073	<	elementCount += numNew;
1074	<	return numNew != 0;
1073	>	elementCount = s + numNew;
1074	>	return true;
1075		}
1076
1077		/**
1078		* Compares the specified Object with this Vector for equality.  Returns
1079		* true if and only if the specified Object is also a List, both Lists
1080		* have the same size, and all corresponding pairs of elements in the two
1081	<	* Lists are <em>equal</em>.  (Two elements <code>e1</code> and
1082	<	* <code>e2</code> are <em>equal</em> if <code>(e1==null ? e2==null :
1083	<	* e1.equals(e2))</code>.)  In other words, two Lists are defined to be
1081	>	* Lists are <em>equal</em>.  (Two elements {@code e1} and
1082	>	* {@code e2} are <em>equal</em> if {@code Objects.equals(e1, e2)}.)
1083	>	* In other words, two Lists are defined to be
1084		* equal if they contain the same elements in the same order.
1085		*
1086		* @param o the Object to be compared for equality with this Vector
#	Line 959 | Line 1111 | public class Vector<E>
1111		* equal, the returned List is empty.)  The returned List is backed by this
1112		* List, so changes in the returned List are reflected in this List, and
1113		* vice-versa.  The returned List supports all of the optional List
1114	<	* operations supported by this List.<p>
1114	>	* operations supported by this List.
1115		*
1116	<	* This method eliminates the need for explicit range operations (of
1117	<	* the sort that commonly exist for arrays).   Any operation that expects
1116	>	* <p>This method eliminates the need for explicit range operations (of
1117	>	* the sort that commonly exist for arrays).  Any operation that expects
1118		* a List can be used as a range operation by operating on a subList view
1119		* instead of a whole List.  For example, the following idiom
1120		* removes a range of elements from a List:
1121		* <pre>
1122	<	*      list.subList(from, to).clear();
1122	>	*      list.subList(from, to).clear();
1123		* </pre>
1124		* Similar idioms may be constructed for indexOf and lastIndexOf,
1125		* and all of the algorithms in the Collections class can be applied to
1126	<	* a subList.<p>
1126	>	* a subList.
1127		*
1128	<	* The semantics of the List returned by this method become undefined if
1128	>	* <p>The semantics of the List returned by this method become undefined if
1129		* the backing list (i.e., this List) is <i>structurally modified</i> in
1130		* any way other than via the returned List.  (Structural modifications are
1131		* those that change the size of the List, or otherwise perturb it in such
#	Line 982 | Line 1134 | public class Vector<E>
1134		* @param fromIndex low endpoint (inclusive) of the subList
1135		* @param toIndex high endpoint (exclusive) of the subList
1136		* @return a view of the specified range within this List
1137	<	* @throws IndexOutOfBoundsException endpoint index value out of range
1138	<	*         <code>(fromIndex &lt; 0 || toIndex &gt; size)</code>
1139	<	* @throws IllegalArgumentException endpoint indices out of order
1140	<	*         <code>(fromIndex &gt; toIndex)</code>
1137	>	* @throws IndexOutOfBoundsException if an endpoint index value is out of range
1138	>	*         {@code (fromIndex < 0 || toIndex > size)}
1139	>	* @throws IllegalArgumentException if the endpoint indices are out of order
1140	>	*         {@code (fromIndex > toIndex)}
1141		*/
1142		public synchronized List<E> subList(int fromIndex, int toIndex) {
1143		return Collections.synchronizedList(super.subList(fromIndex, toIndex),
#	Line 993 | Line 1145 | public class Vector<E>
1145		}
1146
1147		/**
1148	<	* Removes from this List all of the elements whose index is between
1149	<	* fromIndex, inclusive and toIndex, exclusive.  Shifts any succeeding
1150	<	* elements to the left (reduces their index).
1151	<	* This call shortens the ArrayList by (toIndex - fromIndex) elements.  (If
1152	<	* toIndex==fromIndex, this operation has no effect.)
1001	<	*
1002	<	* @param fromIndex index of first element to be removed
1003	<	* @param toIndex index after last element to be removed
1148	>	* Removes from this list all of the elements whose index is between
1149	>	* {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.
1150	>	* Shifts any succeeding elements to the left (reduces their index).
1151	>	* This call shortens the list by {@code (toIndex - fromIndex)} elements.
1152	>	* (If {@code toIndex==fromIndex}, this operation has no effect.)
1153		*/
1154		protected synchronized void removeRange(int fromIndex, int toIndex) {
1155	<	modCount++;
1007	<	int numMoved = elementCount - toIndex;
1155	>	int numMoved = elementCount - toIndex;
1156		System.arraycopy(elementData, toIndex, elementData, fromIndex,
1157		numMoved);
1158
1159	<	// Let gc do its work
1160	<	int newElementCount = elementCount - (toIndex-fromIndex);
1161	<	while (elementCount != newElementCount)
1162	<	elementData[--elementCount] = null;
1159	>	// Let gc do its work
1160	>	modCount++;
1161	>	int newElementCount = elementCount - (toIndex-fromIndex);
1162	>	while (elementCount != newElementCount)
1163	>	elementData[--elementCount] = null;
1164		}
1165
1166		/**
1167	<	* Save the state of the <tt>Vector</tt> instance to a stream (that
1168	<	* is, serialize it).  This method is present merely for synchronization.
1169	<	* It just calls the default writeObject method.
1170	<	*/
1171	<	private synchronized void writeObject(java.io.ObjectOutputStream s)
1172	<	throws java.io.IOException
1173	<	{
1174	<	s.defaultWriteObject();
1167	>	* Save the state of the {@code Vector} instance to a stream (that
1168	>	* is, serialize it).
1169	>	* This method performs synchronization to ensure the consistency
1170	>	* of the serialized data.
1171	>	*/
1172	>	private void writeObject(java.io.ObjectOutputStream s)
1173	>	throws java.io.IOException {
1174	>	final java.io.ObjectOutputStream.PutField fields = s.putFields();
1175	>	final Object[] data;
1176	>	synchronized (this) {
1177	>	fields.put("capacityIncrement", capacityIncrement);
1178	>	fields.put("elementCount", elementCount);
1179	>	data = elementData.clone();
1180	>	}
1181	>	fields.put("elementData", data);
1182	>	s.writeFields();
1183		}
1184
1185		/**
1186	<	* Returns a list-iterator of the elements in this list (in proper
1186	>	* Returns a list iterator over the elements in this list (in proper
1187		* sequence), starting at the specified position in the list.
1188	<	* Obeys the general contract of <tt>List.listIterator(int)</tt>.<p>
1188	>	* The specified index indicates the first element that would be
1189	>	* returned by an initial call to {@link ListIterator#next next}.
1190	>	* An initial call to {@link ListIterator#previous previous} would
1191	>	* return the element with the specified index minus one.
1192	>	*
1193	>	* <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1194		*
1033	–	* The list-iterator is <i>fail-fast</i>: if the list is structurally
1034	–	* modified at any time after the Iterator is created, in any way except
1035	–	* through the list-iterator's own <tt>remove</tt> or <tt>add</tt>
1036	–	* methods, the list-iterator will throw a
1037	–	* <tt>ConcurrentModificationException</tt>.  Thus, in the face of
1038	–	* concurrent modification, the iterator fails quickly and cleanly, rather
1039	–	* than risking arbitrary, non-deterministic behavior at an undetermined
1040	–	* time in the future.
1041	–	*
1042	–	* @param index index of the first element to be returned from the
1043	–	*              list-iterator (by a call to <tt>next</tt>)
1044	–	* @return a ListIterator of the elements in this list (in proper
1045	–	*         sequence), starting at the specified position in the list
1195		* @throws IndexOutOfBoundsException {@inheritDoc}
1047	–	* @see List#listIterator(int)
1196		*/
1197		public synchronized ListIterator<E> listIterator(int index) {
1198	<	if (index < 0 || index > elementCount)
1198	>	if (index < 0 || index > elementCount)
1199		throw new IndexOutOfBoundsException("Index: "+index);
1200	<	return new VectorIterator(index);
1200	>	return new ListItr(index);
1201		}
1202
1203		/**
1204	<	* {@inheritDoc}
1204	>	* Returns a list iterator over the elements in this list (in proper
1205	>	* sequence).
1206	>	*
1207	>	* <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1208	>	*
1209	>	* @see #listIterator(int)
1210		*/
1211		public synchronized ListIterator<E> listIterator() {
1212	<	return new VectorIterator(0);
1212	>	return new ListItr(0);
1213		}
1214
1215		/**
1216		* Returns an iterator over the elements in this list in proper sequence.
1217		*
1218	+	* <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1219	+	*
1220		* @return an iterator over the elements in this list in proper sequence
1221		*/
1222		public synchronized Iterator<E> iterator() {
1223	<	return new VectorIterator(0);
1223	>	return new Itr();
1224		}
1225
1226		/**
1227	<	* A streamlined version of AbstractList.ListItr.
1227	>	* An optimized version of AbstractList.Itr
1228		*/
1229	<	private final class VectorIterator implements ListIterator<E> {
1230	<	int cursor;                // current position
1231	<	int lastRet;               // index of last returned element
1232	<	int expectedModCount;      // to check for CME
1078	<
1079	<	VectorIterator(int index) {
1080	<	cursor = index;
1081	<	expectedModCount = modCount;
1082	<	lastRet = -1;
1083	<	}
1229	>	private class Itr implements Iterator<E> {
1230	>	int cursor;       // index of next element to return
1231	>	int lastRet = -1; // index of last element returned; -1 if no such
1232	>	int expectedModCount = modCount;
1233
1234	<	public boolean hasNext() {
1234	>	public boolean hasNext() {
1235		// Racy but within spec, since modifications are checked
1236		// within or after synchronization in next/previous
1237		return cursor != elementCount;
1238	<	}
1090	<
1091	<	public boolean hasPrevious() {
1092	<	return cursor != 0;
1093	<	}
1094	<
1095	<	public int nextIndex() {
1096	<	return cursor;
1097	<	}
1098	<
1099	<	public int previousIndex() {
1100	<	return cursor - 1;
1101	<	}
1238	>	}
1239
1240	<	public E next() {
1241	<	try {
1240	>	public E next() {
1241	>	synchronized (Vector.this) {
1242	>	checkForComodification();
1243		int i = cursor;
1244	<	E next = get(i);
1245	<	lastRet = i;
1244	>	if (i >= elementCount)
1245	>	throw new NoSuchElementException();
1246		cursor = i + 1;
1247	<	return next;
1248	<	} catch (IndexOutOfBoundsException ex) {
1249	<	throw new NoSuchElementException();
1250	<	} finally {
1251	<	if (expectedModCount != modCount)
1247	>	return elementData(lastRet = i);
1248	>	}
1249	>	}
1250	>
1251	>	public void remove() {
1252	>	if (lastRet == -1)
1253	>	throw new IllegalStateException();
1254	>	synchronized (Vector.this) {
1255	>	checkForComodification();
1256	>	Vector.this.remove(lastRet);
1257	>	expectedModCount = modCount;
1258	>	}
1259	>	cursor = lastRet;
1260	>	lastRet = -1;
1261	>	}
1262	>
1263	>	@Override
1264	>	public void forEachRemaining(Consumer<? super E> action) {
1265	>	Objects.requireNonNull(action);
1266	>	synchronized (Vector.this) {
1267	>	final int size = elementCount;
1268	>	int i = cursor;
1269	>	if (i >= size) {
1270	>	return;
1271	>	}
1272	>	@SuppressWarnings("unchecked")
1273	>	final E[] elementData = (E[]) Vector.this.elementData;
1274	>	if (i >= elementData.length) {
1275		throw new ConcurrentModificationException();
1276	+	}
1277	+	while (i != size && modCount == expectedModCount) {
1278	+	action.accept(elementData[i++]);
1279	+	}
1280	+	// update once at end of iteration to reduce heap write traffic
1281	+	cursor = i;
1282	+	lastRet = i - 1;
1283	+	checkForComodification();
1284		}
1285	<	}
1285	>	}
1286	>
1287	>	final void checkForComodification() {
1288	>	if (modCount != expectedModCount)
1289	>	throw new ConcurrentModificationException();
1290	>	}
1291	>	}
1292
1293	<	public E previous() {
1294	<	try {
1293	>	/**
1294	>	* An optimized version of AbstractList.ListItr
1295	>	*/
1296	>	final class ListItr extends Itr implements ListIterator<E> {
1297	>	ListItr(int index) {
1298	>	super();
1299	>	cursor = index;
1300	>	}
1301	>
1302	>	public boolean hasPrevious() {
1303	>	return cursor != 0;
1304	>	}
1305	>
1306	>	public int nextIndex() {
1307	>	return cursor;
1308	>	}
1309	>
1310	>	public int previousIndex() {
1311	>	return cursor - 1;
1312	>	}
1313	>
1314	>	public E previous() {
1315	>	synchronized (Vector.this) {
1316	>	checkForComodification();
1317		int i = cursor - 1;
1318	<	E prev = get(i);
1319	<	lastRet = i;
1318	>	if (i < 0)
1319	>	throw new NoSuchElementException();
1320		cursor = i;
1321	<	return prev;
1322	<	} catch (IndexOutOfBoundsException ex) {
1323	<	throw new NoSuchElementException();
1324	<	} finally {
1325	<	if (expectedModCount != modCount)
1321	>	return elementData(lastRet = i);
1322	>	}
1323	>	}
1324	>
1325	>	public void set(E e) {
1326	>	if (lastRet == -1)
1327	>	throw new IllegalStateException();
1328	>	synchronized (Vector.this) {
1329	>	checkForComodification();
1330	>	Vector.this.set(lastRet, e);
1331	>	}
1332	>	}
1333	>
1334	>	public void add(E e) {
1335	>	int i = cursor;
1336	>	synchronized (Vector.this) {
1337	>	checkForComodification();
1338	>	Vector.this.add(i, e);
1339	>	expectedModCount = modCount;
1340	>	}
1341	>	cursor = i + 1;
1342	>	lastRet = -1;
1343	>	}
1344	>	}
1345	>
1346	>	@Override
1347	>	public synchronized void forEach(Consumer<? super E> action) {
1348	>	Objects.requireNonNull(action);
1349	>	final int expectedModCount = modCount;
1350	>	@SuppressWarnings("unchecked")
1351	>	final E[] elementData = (E[]) this.elementData;
1352	>	final int elementCount = this.elementCount;
1353	>	for (int i=0; modCount == expectedModCount && i < elementCount; i++) {
1354	>	action.accept(elementData[i]);
1355	>	}
1356	>	if (modCount != expectedModCount) {
1357	>	throw new ConcurrentModificationException();
1358	>	}
1359	>	}
1360	>
1361	>	@Override
1362	>	@SuppressWarnings("unchecked")
1363	>	public synchronized void replaceAll(UnaryOperator<E> operator) {
1364	>	Objects.requireNonNull(operator);
1365	>	final int expectedModCount = modCount;
1366	>	final int size = elementCount;
1367	>	for (int i=0; modCount == expectedModCount && i < size; i++) {
1368	>	elementData[i] = operator.apply((E) elementData[i]);
1369	>	}
1370	>	if (modCount != expectedModCount) {
1371	>	throw new ConcurrentModificationException();
1372	>	}
1373	>	modCount++;
1374	>	}
1375	>
1376	>	@SuppressWarnings("unchecked")
1377	>	@Override
1378	>	public synchronized void sort(Comparator<? super E> c) {
1379	>	final int expectedModCount = modCount;
1380	>	Arrays.sort((E[]) elementData, 0, elementCount, c);
1381	>	if (modCount != expectedModCount) {
1382	>	throw new ConcurrentModificationException();
1383	>	}
1384	>	modCount++;
1385	>	}
1386	>
1387	>	/**
1388	>	* Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
1389	>	* and <em>fail-fast</em> {@link Spliterator} over the elements in this
1390	>	* list.
1391	>	*
1392	>	* <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
1393	>	* {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
1394	>	* Overriding implementations should document the reporting of additional
1395	>	* characteristic values.
1396	>	*
1397	>	* @return a {@code Spliterator} over the elements in this list
1398	>	* @since 1.8
1399	>	*/
1400	>	@Override
1401	>	public Spliterator<E> spliterator() {
1402	>	return new VectorSpliterator<>(this, null, 0, -1, 0);
1403	>	}
1404	>
1405	>	/** Similar to ArrayList Spliterator */
1406	>	static final class VectorSpliterator<E> implements Spliterator<E> {
1407	>	private final Vector<E> list;
1408	>	private Object[] array;
1409	>	private int index; // current index, modified on advance/split
1410	>	private int fence; // -1 until used; then one past last index
1411	>	private int expectedModCount; // initialized when fence set
1412	>
1413	>	/** Create new spliterator covering the given  range */
1414	>	VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,
1415	>	int expectedModCount) {
1416	>	this.list = list;
1417	>	this.array = array;
1418	>	this.index = origin;
1419	>	this.fence = fence;
1420	>	this.expectedModCount = expectedModCount;
1421	>	}
1422	>
1423	>	private int getFence() { // initialize on first use
1424	>	int hi;
1425	>	if ((hi = fence) < 0) {
1426	>	synchronized (list) {
1427	>	array = list.elementData;
1428	>	expectedModCount = list.modCount;
1429	>	hi = fence = list.elementCount;
1430	>	}
1431	>	}
1432	>	return hi;
1433	>	}
1434	>
1435	>	public Spliterator<E> trySplit() {
1436	>	int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1437	>	return (lo >= mid) ? null :
1438	>	new VectorSpliterator<>(list, array, lo, index = mid,
1439	>	expectedModCount);
1440	>	}
1441	>
1442	>	@SuppressWarnings("unchecked")
1443	>	public boolean tryAdvance(Consumer<? super E> action) {
1444	>	int i;
1445	>	if (action == null)
1446	>	throw new NullPointerException();
1447	>	if (getFence() > (i = index)) {
1448	>	index = i + 1;
1449	>	action.accept((E)array[i]);
1450	>	if (list.modCount != expectedModCount)
1451		throw new ConcurrentModificationException();
1452	+	return true;
1453		}
1454	+	return false;
1455		}
1456
1457	<	public void remove() {
1458	<	if (lastRet == -1)
1459	<	throw new IllegalStateException();
1460	<	if (expectedModCount != modCount)
1461	<	throw new ConcurrentModificationException();
1462	<	try {
1463	<	Vector.this.remove(lastRet);
1464	<	if (lastRet < cursor)
1465	<	cursor--;
1466	<	lastRet = -1;
1467	<	expectedModCount = modCount;
1468	<	} catch (IndexOutOfBoundsException ex) {
1469	<	throw new ConcurrentModificationException();
1470	<	}
1471	<	}
1472	<
1473	<	public void set(E e) {
1474	<	if (lastRet == -1)
1475	<	throw new IllegalStateException();
1476	<	if (expectedModCount != modCount)
1477	<	throw new ConcurrentModificationException();
1478	<	try {
1479	<	Vector.this.set(lastRet, e);
1480	<	expectedModCount = modCount;
1481	<	} catch (IndexOutOfBoundsException ex) {
1158	<	throw new ConcurrentModificationException();
1159	<	}
1160	<	}
1457	>	@SuppressWarnings("unchecked")
1458	>	public void forEachRemaining(Consumer<? super E> action) {
1459	>	int i, hi; // hoist accesses and checks from loop
1460	>	Vector<E> lst; Object[] a;
1461	>	if (action == null)
1462	>	throw new NullPointerException();
1463	>	if ((lst = list) != null) {
1464	>	if ((hi = fence) < 0) {
1465	>	synchronized (lst) {
1466	>	expectedModCount = lst.modCount;
1467	>	a = array = lst.elementData;
1468	>	hi = fence = lst.elementCount;
1469	>	}
1470	>	}
1471	>	else
1472	>	a = array;
1473	>	if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {
1474	>	while (i < hi)
1475	>	action.accept((E) a[i++]);
1476	>	if (lst.modCount == expectedModCount)
1477	>	return;
1478	>	}
1479	>	}
1480	>	throw new ConcurrentModificationException();
1481	>	}
1482
1483	<	public void add(E e) {
1484	<	if (expectedModCount != modCount)
1485	<	throw new ConcurrentModificationException();
1486	<	try {
1487	<	int i = cursor;
1488	<	Vector.this.add(i, e);
1489	<	cursor = i + 1;
1169	<	lastRet = -1;
1170	<	expectedModCount = modCount;
1171	<	} catch (IndexOutOfBoundsException ex) {
1172	<	throw new ConcurrentModificationException();
1173	<	}
1174	<	}
1483	>	public long estimateSize() {
1484	>	return getFence() - index;
1485	>	}
1486	>
1487	>	public int characteristics() {
1488	>	return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
1489	>	}
1490		}
1491		}

Diff Legend

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