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.2 by jsr166, Sat Nov 26 03:12:10 2005 UTC vs.
Revision 1.55 by jsr166, Wed May 22 17:36:58 2019 UTC

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

Diff Legend

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