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.22 by jsr166, Tue Sep 11 15:38:19 2007 UTC vs.
Revision 1.57 by jsr166, Thu Oct 10 16:53:08 2019 UTC

#	Line 1 | Line 1
1		/*
2	<	* Copyright 1994-2007 Sun Microsystems, Inc.  All Rights Reserved.
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		* This code is free software; you can redistribute it and/or modify it
6		* under the terms of the GNU General Public License version 2 only, as
7	<	* published by the Free Software Foundation.  Sun designates this
7	>	* published by the Free Software Foundation.  Oracle designates this
8		* particular file as subject to the "Classpath" exception as provided
9	<	* by Sun in the LICENSE file that accompanied this code.
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
#	Line 18 | Line 18
18		* 2 along with this work; if not, write to the Free Software Foundation,
19		* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20		*
21	<	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22	<	* CA 95054 USA or visit www.sun.com if you need additional information or
23	<	* have any questions.
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.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} class implements a growable array of
39		* objects. Like an array, it contains components that can be
#	Line 41 | Line 50 | package java.util;
50		* capacity of a vector before inserting a large number of
51		* components; this reduces the amount of incremental reallocation.
52		*
53	<	* <p><a name="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
#	Line 52 | Line 61 | package java.util;
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.
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
#	Line 64 | Line 75 | package java.util;
75		*
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}/../technotes/guides/collections/index.html"> Java
79	<	* Collections Framework</a>.  Unlike the new collection
80	<	* implementations, {@code Vector} is synchronized.
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
73	–	* @version %I%, %G%
88		* @see Collection
75	–	* @see List
76	–	* @see ArrayList
89		* @see LinkedList
90	<	* @since   JDK1.0
90	>	* @since   1.0
91		*/
92		public class Vector<E>
93		extends AbstractList<E>
#	Line 90 | Line 102 | public class Vector<E>
102		*
103		* @serial
104		*/
105	+	@SuppressWarnings("serial") // Conditionally serializable
106		protected Object[] elementData;
107
108		/**
#	Line 112 | Line 125 | public class Vector<E>
125		protected int capacityIncrement;
126
127		/** use serialVersionUID from JDK 1.0.2 for interoperability */
128	+	// OPENJDK @java.io.Serial
129		private static final long serialVersionUID = -2767605614048989439L;
130
131		/**
#	Line 125 | Line 139 | public class Vector<E>
139		*         is negative
140		*/
141		public Vector(int initialCapacity, int capacityIncrement) {
142	<	super();
142	>	super();
143		if (initialCapacity < 0)
144		throw new IllegalArgumentException("Illegal Capacity: "+
145		initialCapacity);
146	<	this.elementData = new Object[initialCapacity];
147	<	this.capacityIncrement = capacityIncrement;
146	>	this.elementData = new Object[initialCapacity];
147	>	this.capacityIncrement = capacityIncrement;
148		}
149
150		/**
#	Line 142 | Line 156 | public class Vector<E>
156		*         is negative
157		*/
158		public Vector(int initialCapacity) {
159	<	this(initialCapacity, 0);
159	>	this(initialCapacity, 0);
160		}
161
162		/**
#	Line 151 | Line 165 | public class Vector<E>
165		* zero.
166		*/
167		public Vector() {
168	<	this(10);
168	>	this(10);
169		}
170
171		/**
#	Line 165 | Line 179 | public class Vector<E>
179		* @since   1.2
180		*/
181		public Vector(Collection<? extends E> c) {
182	<	elementData = c.toArray();
183	<	elementCount = elementData.length;
184	<	// c.toArray might (incorrectly) not return Object[] (see 6260652)
185	<	if (elementData.getClass() != Object[].class)
186	<	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
182	>	elementData = c.toArray();
183	>	elementCount = elementData.length;
184	>	// defend against c.toArray (incorrectly) not returning Object[]
185	>	// (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
186	>	if (elementData.getClass() != Object[].class)
187	>	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
188		}
189
190		/**
#	Line 186 | Line 201 | public class Vector<E>
201		* @see #toArray(Object[])
202		*/
203		public synchronized void copyInto(Object[] anArray) {
204	<	System.arraycopy(elementData, 0, anArray, 0, elementCount);
204	>	System.arraycopy(elementData, 0, anArray, 0, elementCount);
205		}
206
207		/**
#	Line 198 | Line 213 | public class Vector<E>
213		* minimize the storage of a vector.
214		*/
215		public synchronized void trimToSize() {
216	<	modCount++;
217	<	int oldCapacity = elementData.length;
218	<	if (elementCount < oldCapacity) {
216	>	modCount++;
217	>	int oldCapacity = elementData.length;
218	>	if (elementCount < oldCapacity) {
219		elementData = Arrays.copyOf(elementData, elementCount);
220	<	}
220	>	}
221		}
222
223		/**
#	Line 223 | Line 238 | public class Vector<E>
238		* @param minCapacity the desired minimum capacity
239		*/
240		public synchronized void ensureCapacity(int minCapacity) {
241	<	modCount++;
242	<	ensureCapacityHelper(minCapacity);
241	>	if (minCapacity > 0) {
242	>	modCount++;
243	>	if (minCapacity > elementData.length)
244	>	grow(minCapacity);
245	>	}
246		}
247
248		/**
249	<	* This implements the unsynchronized semantics of ensureCapacity.
250	<	* Synchronized methods in this class can internally call this
251	<	* method for ensuring capacity without incurring the cost of an
252	<	* extra synchronization.
253	<	*
254	<	* @see #ensureCapacity(int)
255	<	*/
256	<	private void ensureCapacityHelper(int minCapacity) {
257	<	int oldCapacity = elementData.length;
258	<	if (minCapacity > oldCapacity) {
259	<	Object[] oldData = elementData;
260	<	int newCapacity = (capacityIncrement > 0) ?
261	<	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
262	<	if (newCapacity < minCapacity) {
263	<	newCapacity = minCapacity;
264	<	}
265	<	elementData = Arrays.copyOf(elementData, newCapacity);
248	<	}
249	>	* Increases the capacity to ensure that it can hold at least the
250	>	* number of elements specified by the minimum capacity argument.
251	>	*
252	>	* @param minCapacity the desired minimum capacity
253	>	* @throws OutOfMemoryError if minCapacity is less than zero
254	>	*/
255	>	private Object[] grow(int minCapacity) {
256	>	int oldCapacity = elementData.length;
257	>	int newCapacity = ArraysSupport.newLength(oldCapacity,
258	>	minCapacity - oldCapacity, /* minimum growth */
259	>	capacityIncrement > 0 ? capacityIncrement : oldCapacity
260	>	/* preferred growth */);
261	>	return elementData = Arrays.copyOf(elementData, newCapacity);
262	>	}
263	>
264	>	private Object[] grow() {
265	>	return grow(elementCount + 1);
266		}
267
268		/**
#	Line 258 | Line 275 | public class Vector<E>
275		* @throws ArrayIndexOutOfBoundsException if the new size is negative
276		*/
277		public synchronized void setSize(int newSize) {
278	<	modCount++;
279	<	if (newSize > elementCount) {
280	<	ensureCapacityHelper(newSize);
281	<	} else {
282	<	for (int i = newSize ; i < elementCount ; i++) {
283	<	elementData[i] = null;
284	<	}
268	<	}
269	<	elementCount = newSize;
278	>	modCount++;
279	>	if (newSize > elementData.length)
280	>	grow(newSize);
281	>	final Object[] es = elementData;
282	>	for (int to = elementCount, i = newSize; i < to; i++)
283	>	es[i] = null;
284	>	elementCount = newSize;
285		}
286
287		/**
#	Line 277 | Line 292 | public class Vector<E>
292		*          of this vector)
293		*/
294		public synchronized int capacity() {
295	<	return elementData.length;
295	>	return elementData.length;
296		}
297
298		/**
#	Line 286 | Line 301 | public class Vector<E>
301		* @return  the number of components in this vector
302		*/
303		public synchronized int size() {
304	<	return elementCount;
304	>	return elementCount;
305		}
306
307		/**
#	Line 297 | Line 312 | public class Vector<E>
312		*          {@code false} otherwise.
313		*/
314		public synchronized boolean isEmpty() {
315	<	return elementCount == 0;
315	>	return elementCount == 0;
316		}
317
318		/**
319		* Returns an enumeration of the components of this vector. The
320		* returned {@code Enumeration} object will generate all items in
321		* this vector. The first item generated is the item at index {@code 0},
322	<	* then the item at index {@code 1}, and so on.
322	>	* then the item at index {@code 1}, and so on. If the vector is
323	>	* structurally modified while enumerating over the elements then the
324	>	* results of enumerating are undefined.
325		*
326		* @return  an enumeration of the components of this vector
327		* @see     Iterator
328		*/
329		public Enumeration<E> elements() {
330	<	return new Enumeration<E>() {
331	<	int count = 0;
330	>	return new Enumeration<E>() {
331	>	int count = 0;
332	>
333	>	public boolean hasMoreElements() {
334	>	return count < elementCount;
335	>	}
336
337	<	public boolean hasMoreElements() {
338	<	return count < elementCount;
339	<	}
340	<
341	<	public E nextElement() {
342	<	synchronized (Vector.this) {
343	<	if (count < elementCount) {
344	<	return elementData(count++);
345	<	}
325	<	}
326	<	throw new NoSuchElementException("Vector Enumeration");
327	<	}
328	<	};
337	>	public E nextElement() {
338	>	synchronized (Vector.this) {
339	>	if (count < elementCount) {
340	>	return elementData(count++);
341	>	}
342	>	}
343	>	throw new NoSuchElementException("Vector Enumeration");
344	>	}
345	>	};
346		}
347
348		/**
349		* Returns {@code true} if this vector contains the specified element.
350		* More formally, returns {@code true} if and only if this vector
351		* contains at least one element {@code e} such that
352	<	* <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
352	>	* {@code Objects.equals(o, e)}.
353		*
354		* @param o element whose presence in this vector is to be tested
355		* @return {@code true} if this vector contains the specified element
356		*/
357		public boolean contains(Object o) {
358	<	return indexOf(o, 0) >= 0;
358	>	return indexOf(o, 0) >= 0;
359		}
360
361		/**
362		* Returns the index of the first occurrence of the specified element
363		* in this vector, or -1 if this vector does not contain the element.
364		* More formally, returns the lowest index {@code i} such that
365	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
365	>	* {@code Objects.equals(o, get(i))},
366		* or -1 if there is no such index.
367		*
368		* @param o element to search for
#	Line 353 | Line 370 | public class Vector<E>
370		*         this vector, or -1 if this vector does not contain the element
371		*/
372		public int indexOf(Object o) {
373	<	return indexOf(o, 0);
373	>	return indexOf(o, 0);
374		}
375
376		/**
#	Line 361 | Line 378 | public class Vector<E>
378		* this vector, searching forwards from {@code index}, or returns -1 if
379		* the element is not found.
380		* More formally, returns the lowest index {@code i} such that
381	<	* <tt>(i&nbsp;&gt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
381	>	* {@code (i >= index && Objects.equals(o, get(i)))},
382		* or -1 if there is no such index.
383		*
384		* @param o element to search for
#	Line 373 | Line 390 | public class Vector<E>
390		* @see     Object#equals(Object)
391		*/
392		public synchronized int indexOf(Object o, int index) {
393	<	if (o == null) {
394	<	for (int i = index ; i < elementCount ; i++)
395	<	if (elementData[i]==null)
396	<	return i;
397	<	} else {
398	<	for (int i = index ; i < elementCount ; i++)
399	<	if (o.equals(elementData[i]))
400	<	return i;
401	<	}
402	<	return -1;
393	>	if (o == null) {
394	>	for (int i = index ; i < elementCount ; i++)
395	>	if (elementData[i]==null)
396	>	return i;
397	>	} else {
398	>	for (int i = index ; i < elementCount ; i++)
399	>	if (o.equals(elementData[i]))
400	>	return i;
401	>	}
402	>	return -1;
403		}
404
405		/**
406		* Returns the index of the last occurrence of the specified element
407		* in this vector, or -1 if this vector does not contain the element.
408		* More formally, returns the highest index {@code i} such that
409	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
409	>	* {@code Objects.equals(o, get(i))},
410		* or -1 if there is no such index.
411		*
412		* @param o element to search for
#	Line 397 | Line 414 | public class Vector<E>
414		*         this vector, or -1 if this vector does not contain the element
415		*/
416		public synchronized int lastIndexOf(Object o) {
417	<	return lastIndexOf(o, elementCount-1);
417	>	return lastIndexOf(o, elementCount-1);
418		}
419
420		/**
#	Line 405 | Line 422 | public class Vector<E>
422		* this vector, searching backwards from {@code index}, or returns -1 if
423		* the element is not found.
424		* More formally, returns the highest index {@code i} such that
425	<	* <tt>(i&nbsp;&lt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
425	>	* {@code (i <= index && Objects.equals(o, get(i)))},
426		* or -1 if there is no such index.
427		*
428		* @param o element to search for
#	Line 420 | Line 437 | public class Vector<E>
437		if (index >= elementCount)
438		throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
439
440	<	if (o == null) {
441	<	for (int i = index; i >= 0; i--)
442	<	if (elementData[i]==null)
443	<	return i;
444	<	} else {
445	<	for (int i = index; i >= 0; i--)
446	<	if (o.equals(elementData[i]))
447	<	return i;
448	<	}
449	<	return -1;
440	>	if (o == null) {
441	>	for (int i = index; i >= 0; i--)
442	>	if (elementData[i]==null)
443	>	return i;
444	>	} else {
445	>	for (int i = index; i >= 0; i--)
446	>	if (o.equals(elementData[i]))
447	>	return i;
448	>	}
449	>	return -1;
450		}
451
452		/**
#	Line 441 | Line 458 | public class Vector<E>
458		* @param      index   an index into this vector
459		* @return     the component at the specified index
460		* @throws ArrayIndexOutOfBoundsException if the index is out of range
461	<	*         ({@code index < 0 || index >= size()})
461	>	*         ({@code index < 0 || index >= size()})
462		*/
463		public synchronized E elementAt(int index) {
464	<	if (index >= elementCount) {
465	<	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
466	<	}
464	>	if (index >= elementCount) {
465	>	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
466	>	}
467
468		return elementData(index);
469		}
#	Line 459 | Line 476 | public class Vector<E>
476		* @throws NoSuchElementException if this vector has no components
477		*/
478		public synchronized E firstElement() {
479	<	if (elementCount == 0) {
480	<	throw new NoSuchElementException();
481	<	}
482	<	return elementData(0);
479	>	if (elementCount == 0) {
480	>	throw new NoSuchElementException();
481	>	}
482	>	return elementData(0);
483		}
484
485		/**
486		* Returns the last component of the vector.
487		*
488		* @return  the last component of the vector, i.e., the component at index
489	<	*          <code>size()&nbsp;-&nbsp;1</code>.
489	>	*          {@code size() - 1}
490		* @throws NoSuchElementException if this vector is empty
491		*/
492		public synchronized E lastElement() {
493	<	if (elementCount == 0) {
494	<	throw new NoSuchElementException();
495	<	}
496	<	return elementData(elementCount - 1);
493	>	if (elementCount == 0) {
494	>	throw new NoSuchElementException();
495	>	}
496	>	return elementData(elementCount - 1);
497		}
498
499		/**
#	Line 497 | Line 514 | public class Vector<E>
514		* @param      obj     what the component is to be set to
515		* @param      index   the specified index
516		* @throws ArrayIndexOutOfBoundsException if the index is out of range
517	<	*         ({@code index < 0 || index >= size()})
517	>	*         ({@code index < 0 || index >= size()})
518		*/
519		public synchronized void setElementAt(E obj, int index) {
520	<	if (index >= elementCount) {
521	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
522	<	elementCount);
523	<	}
524	<	elementData[index] = obj;
520	>	if (index >= elementCount) {
521	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
522	>	elementCount);
523	>	}
524	>	elementData[index] = obj;
525		}
526
527		/**
#	Line 524 | Line 541 | public class Vector<E>
541		*
542		* @param      index   the index of the object to remove
543		* @throws ArrayIndexOutOfBoundsException if the index is out of range
544	<	*         ({@code index < 0 || index >= size()})
544	>	*         ({@code index < 0 || index >= size()})
545		*/
546		public synchronized void removeElementAt(int index) {
547	<	modCount++;
548	<	if (index >= elementCount) {
549	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
550	<	elementCount);
551	<	}
552	<	else if (index < 0) {
553	<	throw new ArrayIndexOutOfBoundsException(index);
554	<	}
555	<	int j = elementCount - index - 1;
556	<	if (j > 0) {
557	<	System.arraycopy(elementData, index + 1, elementData, index, j);
558	<	}
559	<	elementCount--;
560	<	elementData[elementCount] = null; /* to let gc do its work */
547	>	if (index >= elementCount) {
548	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
549	>	elementCount);
550	>	}
551	>	else if (index < 0) {
552	>	throw new ArrayIndexOutOfBoundsException(index);
553	>	}
554	>	int j = elementCount - index - 1;
555	>	if (j > 0) {
556	>	System.arraycopy(elementData, index + 1, elementData, index, j);
557	>	}
558	>	modCount++;
559	>	elementCount--;
560	>	elementData[elementCount] = null; /* to let gc do its work */
561	>	// checkInvariants();
562		}
563
564		/**
#	Line 564 | Line 582 | public class Vector<E>
582		* @param      obj     the component to insert
583		* @param      index   where to insert the new component
584		* @throws ArrayIndexOutOfBoundsException if the index is out of range
585	<	*         ({@code index < 0 || index > size()})
585	>	*         ({@code index < 0 || index > size()})
586		*/
587		public synchronized void insertElementAt(E obj, int index) {
588	<	modCount++;
589	<	if (index > elementCount) {
590	<	throw new ArrayIndexOutOfBoundsException(index
591	<	+ " > " + elementCount);
592	<	}
593	<	ensureCapacityHelper(elementCount + 1);
594	<	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
595	<	elementData[index] = obj;
596	<	elementCount++;
588	>	if (index > elementCount) {
589	>	throw new ArrayIndexOutOfBoundsException(index
590	>	+ " > " + elementCount);
591	>	}
592	>	modCount++;
593	>	final int s = elementCount;
594	>	Object[] elementData = this.elementData;
595	>	if (s == elementData.length)
596	>	elementData = grow();
597	>	System.arraycopy(elementData, index,
598	>	elementData, index + 1,
599	>	s - index);
600	>	elementData[index] = obj;
601	>	elementCount = s + 1;
602		}
603
604		/**
#	Line 590 | Line 613 | public class Vector<E>
613		* @param   obj   the component to be added
614		*/
615		public synchronized void addElement(E obj) {
616	<	modCount++;
617	<	ensureCapacityHelper(elementCount + 1);
595	<	elementData[elementCount++] = obj;
616	>	modCount++;
617	>	add(obj, elementData, elementCount);
618		}
619
620		/**
#	Line 611 | Line 633 | public class Vector<E>
633		*          vector; {@code false} otherwise.
634		*/
635		public synchronized boolean removeElement(Object obj) {
636	<	modCount++;
637	<	int i = indexOf(obj);
638	<	if (i >= 0) {
639	<	removeElementAt(i);
640	<	return true;
641	<	}
642	<	return false;
636	>	modCount++;
637	>	int i = indexOf(obj);
638	>	if (i >= 0) {
639	>	removeElementAt(i);
640	>	return true;
641	>	}
642	>	return false;
643		}
644
645		/**
#	Line 627 | Line 649 | public class Vector<E>
649		* method (which is part of the {@link List} interface).
650		*/
651		public synchronized void removeAllElements() {
652	+	final Object[] es = elementData;
653	+	for (int to = elementCount, i = elementCount = 0; i < to; i++)
654	+	es[i] = null;
655		modCount++;
631	–	// Let gc do its work
632	–	for (int i = 0; i < elementCount; i++)
633	–	elementData[i] = null;
634	–
635	–	elementCount = 0;
656		}
657
658		/**
#	Line 643 | Line 663 | public class Vector<E>
663		* @return  a clone of this vector
664		*/
665		public synchronized Object clone() {
666	<	try {
667	<	@SuppressWarnings("unchecked")
668	<	Vector<E> v = (Vector<E>) super.clone();
669	<	v.elementData = Arrays.copyOf(elementData, elementCount);
670	<	v.modCount = 0;
671	<	return v;
672	<	} catch (CloneNotSupportedException e) {
673	<	// this shouldn't happen, since we are Cloneable
674	<	throw new InternalError();
675	<	}
666	>	try {
667	>	@SuppressWarnings("unchecked")
668	>	Vector<E> v = (Vector<E>) super.clone();
669	>	v.elementData = Arrays.copyOf(elementData, elementCount);
670	>	v.modCount = 0;
671	>	return v;
672	>	} catch (CloneNotSupportedException e) {
673	>	// this shouldn't happen, since we are Cloneable
674	>	throw new InternalError(e);
675	>	}
676		}
677
678		/**
#	Line 679 | Line 699 | public class Vector<E>
699		* of the Vector <em>only</em> if the caller knows that the Vector
700		* does not contain any null elements.)
701		*
702	+	* @param <T> type of array elements. The same type as {@code <E>} or a
703	+	* supertype of {@code <E>}.
704		* @param a the array into which the elements of the Vector are to
705	<	*          be stored, if it is big enough; otherwise, a new array of the
706	<	*          same runtime type is allocated for this purpose.
705	>	*          be stored, if it is big enough; otherwise, a new array of the
706	>	*          same runtime type is allocated for this purpose.
707		* @return an array containing the elements of the Vector
708	<	* @throws ArrayStoreException if the runtime type of a is not a supertype
709	<	* of the runtime type of every element in this Vector
708	>	* @throws ArrayStoreException if the runtime type of a, {@code <T>}, is not
709	>	* a supertype of the runtime type, {@code <E>}, of every element in this
710	>	* Vector
711		* @throws NullPointerException if the given array is null
712		* @since 1.2
713		*/
#	Line 693 | Line 716 | public class Vector<E>
716		if (a.length < elementCount)
717		return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
718
719	<	System.arraycopy(elementData, 0, a, 0, elementCount);
719	>	System.arraycopy(elementData, 0, a, 0, elementCount);
720
721		if (a.length > elementCount)
722		a[elementCount] = null;
#	Line 705 | Line 728 | public class Vector<E>
728
729		@SuppressWarnings("unchecked")
730		E elementData(int index) {
731	<	return (E) elementData[index];
731	>	return (E) elementData[index];
732	>	}
733	>
734	>	@SuppressWarnings("unchecked")
735	>	static <E> E elementAt(Object[] es, int index) {
736	>	return (E) es[index];
737		}
738
739		/**
#	Line 718 | Line 746 | public class Vector<E>
746		* @since 1.2
747		*/
748		public synchronized E get(int index) {
749	<	if (index >= elementCount)
750	<	throw new ArrayIndexOutOfBoundsException(index);
749	>	if (index >= elementCount)
750	>	throw new ArrayIndexOutOfBoundsException(index);
751
752	<	return elementData(index);
752	>	return elementData(index);
753		}
754
755		/**
#	Line 732 | Line 760 | public class Vector<E>
760		* @param element element to be stored at the specified position
761		* @return the element previously at the specified position
762		* @throws ArrayIndexOutOfBoundsException if the index is out of range
763	<	*         ({@code index < 0 || index >= size()})
763	>	*         ({@code index < 0 || index >= size()})
764		* @since 1.2
765		*/
766		public synchronized E set(int index, E element) {
767	<	if (index >= elementCount)
768	<	throw new ArrayIndexOutOfBoundsException(index);
767	>	if (index >= elementCount)
768	>	throw new ArrayIndexOutOfBoundsException(index);
769
770	<	E oldValue = elementData(index);
771	<	elementData[index] = element;
772	<	return oldValue;
770	>	E oldValue = elementData(index);
771	>	elementData[index] = element;
772	>	return oldValue;
773	>	}
774	>
775	>	/**
776	>	* This helper method split out from add(E) to keep method
777	>	* bytecode size under 35 (the -XX:MaxInlineSize default value),
778	>	* which helps when add(E) is called in a C1-compiled loop.
779	>	*/
780	>	private void add(E e, Object[] elementData, int s) {
781	>	if (s == elementData.length)
782	>	elementData = grow();
783	>	elementData[s] = e;
784	>	elementCount = s + 1;
785	>	// checkInvariants();
786		}
787
788		/**
#	Line 752 | Line 793 | public class Vector<E>
793		* @since 1.2
794		*/
795		public synchronized boolean add(E e) {
796	<	modCount++;
797	<	ensureCapacityHelper(elementCount + 1);
757	<	elementData[elementCount++] = e;
796	>	modCount++;
797	>	add(e, elementData, elementCount);
798		return true;
799		}
800
#	Line 762 | Line 802 | public class Vector<E>
802		* Removes the first occurrence of the specified element in this Vector
803		* If the Vector does not contain the element, it is unchanged.  More
804		* formally, removes the element with the lowest index i such that
805	<	* {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
805	>	* {@code Objects.equals(o, get(i))} (if such
806		* an element exists).
807		*
808		* @param o element to be removed from this Vector, if present
#	Line 793 | Line 833 | public class Vector<E>
833		* Shifts any subsequent elements to the left (subtracts one from their
834		* indices).  Returns the element that was removed from the Vector.
835		*
796	–	* @throws ArrayIndexOutOfBoundsException if the index is out of range
797	–	*         ({@code index < 0 || index >= size()})
836		* @param index the index of the element to be removed
837		* @return element that was removed
838	+	* @throws ArrayIndexOutOfBoundsException if the index is out of range
839	+	*         ({@code index < 0 || index >= size()})
840		* @since 1.2
841		*/
842		public synchronized E remove(int index) {
843	<	modCount++;
844	<	if (index >= elementCount)
845	<	throw new ArrayIndexOutOfBoundsException(index);
846	<	E oldValue = elementData(index);
847	<
848	<	int numMoved = elementCount - index - 1;
849	<	if (numMoved > 0)
850	<	System.arraycopy(elementData, index+1, elementData, index,
851	<	numMoved);
852	<	elementData[--elementCount] = null; // Let gc do its work
843	>	modCount++;
844	>	if (index >= elementCount)
845	>	throw new ArrayIndexOutOfBoundsException(index);
846	>	E oldValue = elementData(index);
847	>
848	>	int numMoved = elementCount - index - 1;
849	>	if (numMoved > 0)
850	>	System.arraycopy(elementData, index+1, elementData, index,
851	>	numMoved);
852	>	elementData[--elementCount] = null; // Let gc do its work
853
854	<	return oldValue;
854	>	// checkInvariants();
855	>	return oldValue;
856		}
857
858		/**
#	Line 833 | Line 874 | public class Vector<E>
874		* @param   c a collection whose elements will be tested for containment
875		*          in this Vector
876		* @return true if this Vector contains all of the elements in the
877	<	*         specified collection
877	>	*         specified collection
878		* @throws NullPointerException if the specified collection is null
879		*/
880		public synchronized boolean containsAll(Collection<?> c) {
#	Line 853 | Line 894 | public class Vector<E>
894		* @throws NullPointerException if the specified collection is null
895		* @since 1.2
896		*/
897	<	public synchronized boolean addAll(Collection<? extends E> c) {
857	<	modCount++;
897	>	public boolean addAll(Collection<? extends E> c) {
898		Object[] a = c.toArray();
899	+	modCount++;
900		int numNew = a.length;
901	<	ensureCapacityHelper(elementCount + numNew);
902	<	System.arraycopy(a, 0, elementData, elementCount, numNew);
903	<	elementCount += numNew;
904	<	return numNew != 0;
901	>	if (numNew == 0)
902	>	return false;
903	>	synchronized (this) {
904	>	Object[] elementData = this.elementData;
905	>	final int s = elementCount;
906	>	if (numNew > elementData.length - s)
907	>	elementData = grow(s + numNew);
908	>	System.arraycopy(a, 0, elementData, s, numNew);
909	>	elementCount = s + numNew;
910	>	// checkInvariants();
911	>	return true;
912	>	}
913		}
914
915		/**
#	Line 871 | Line 920 | public class Vector<E>
920		* @return true if this Vector changed as a result of the call
921		* @throws ClassCastException if the types of one or more elements
922		*         in this vector are incompatible with the specified
923	<	*         collection (optional)
923	>	*         collection
924	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
925		* @throws NullPointerException if this vector contains one or more null
926		*         elements and the specified collection does not support null
927	<	*         elements (optional), or if the specified collection is null
927	>	*         elements
928	>	* (<a href="Collection.html#optional-restrictions">optional</a>),
929	>	*         or if the specified collection is null
930		* @since 1.2
931		*/
932	<	public synchronized boolean removeAll(Collection<?> c) {
933	<	return super.removeAll(c);
932	>	public boolean removeAll(Collection<?> c) {
933	>	Objects.requireNonNull(c);
934	>	return bulkRemove(e -> c.contains(e));
935		}
936
937		/**
#	Line 891 | Line 944 | public class Vector<E>
944		* @return true if this Vector changed as a result of the call
945		* @throws ClassCastException if the types of one or more elements
946		*         in this vector are incompatible with the specified
947	<	*         collection (optional)
947	>	*         collection
948	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
949		* @throws NullPointerException if this vector contains one or more null
950		*         elements and the specified collection does not support null
951	<	*         elements (optional), or if the specified collection is null
951	>	*         elements
952	>	*         (<a href="Collection.html#optional-restrictions">optional</a>),
953	>	*         or if the specified collection is null
954		* @since 1.2
955		*/
956	<	public synchronized boolean retainAll(Collection<?> c)  {
957	<	return super.retainAll(c);
956	>	public boolean retainAll(Collection<?> c) {
957	>	Objects.requireNonNull(c);
958	>	return bulkRemove(e -> !c.contains(e));
959	>	}
960	>
961	>	/**
962	>	* @throws NullPointerException {@inheritDoc}
963	>	*/
964	>	@Override
965	>	public boolean removeIf(Predicate<? super E> filter) {
966	>	Objects.requireNonNull(filter);
967	>	return bulkRemove(filter);
968	>	}
969	>
970	>	// A tiny bit set implementation
971	>
972	>	private static long[] nBits(int n) {
973	>	return new long[((n - 1) >> 6) + 1];
974	>	}
975	>	private static void setBit(long[] bits, int i) {
976	>	bits[i >> 6] |= 1L << i;
977	>	}
978	>	private static boolean isClear(long[] bits, int i) {
979	>	return (bits[i >> 6] & (1L << i)) == 0;
980	>	}
981	>
982	>	private synchronized boolean bulkRemove(Predicate<? super E> filter) {
983	>	int expectedModCount = modCount;
984	>	final Object[] es = elementData;
985	>	final int end = elementCount;
986	>	int i;
987	>	// Optimize for initial run of survivors
988	>	for (i = 0; i < end && !filter.test(elementAt(es, i)); i++)
989	>	;
990	>	// Tolerate predicates that reentrantly access the collection for
991	>	// read (but writers still get CME), so traverse once to find
992	>	// elements to delete, a second pass to physically expunge.
993	>	if (i < end) {
994	>	final int beg = i;
995	>	final long[] deathRow = nBits(end - beg);
996	>	deathRow[0] = 1L;   // set bit 0
997	>	for (i = beg + 1; i < end; i++)
998	>	if (filter.test(elementAt(es, i)))
999	>	setBit(deathRow, i - beg);
1000	>	if (modCount != expectedModCount)
1001	>	throw new ConcurrentModificationException();
1002	>	modCount++;
1003	>	int w = beg;
1004	>	for (i = beg; i < end; i++)
1005	>	if (isClear(deathRow, i - beg))
1006	>	es[w++] = es[i];
1007	>	for (i = elementCount = w; i < end; i++)
1008	>	es[i] = null;
1009	>	// checkInvariants();
1010	>	return true;
1011	>	} else {
1012	>	if (modCount != expectedModCount)
1013	>	throw new ConcurrentModificationException();
1014	>	// checkInvariants();
1015	>	return false;
1016	>	}
1017		}
1018
1019		/**
#	Line 919 | Line 1034 | public class Vector<E>
1034		* @since 1.2
1035		*/
1036		public synchronized boolean addAll(int index, Collection<? extends E> c) {
1037	<	modCount++;
1038	<	if (index < 0 || index > elementCount)
924	<	throw new ArrayIndexOutOfBoundsException(index);
1037	>	if (index < 0 || index > elementCount)
1038	>	throw new ArrayIndexOutOfBoundsException(index);
1039
1040		Object[] a = c.toArray();
1041	<	int numNew = a.length;
1042	<	ensureCapacityHelper(elementCount + numNew);
1043	<
1044	<	int numMoved = elementCount - index;
1045	<	if (numMoved > 0)
1046	<	System.arraycopy(elementData, index, elementData, index + numNew,
1047	<	numMoved);
1048	<
1041	>	modCount++;
1042	>	int numNew = a.length;
1043	>	if (numNew == 0)
1044	>	return false;
1045	>	Object[] elementData = this.elementData;
1046	>	final int s = elementCount;
1047	>	if (numNew > elementData.length - s)
1048	>	elementData = grow(s + numNew);
1049	>
1050	>	int numMoved = s - index;
1051	>	if (numMoved > 0)
1052	>	System.arraycopy(elementData, index,
1053	>	elementData, index + numNew,
1054	>	numMoved);
1055		System.arraycopy(a, 0, elementData, index, numNew);
1056	<	elementCount += numNew;
1057	<	return numNew != 0;
1056	>	elementCount = s + numNew;
1057	>	// checkInvariants();
1058	>	return true;
1059		}
1060
1061		/**
#	Line 942 | Line 1063 | public class Vector<E>
1063		* true if and only if the specified Object is also a List, both Lists
1064		* have the same size, and all corresponding pairs of elements in the two
1065		* Lists are <em>equal</em>.  (Two elements {@code e1} and
1066	<	* {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
1067	<	* e1.equals(e2))}.)  In other words, two Lists are defined to be
1066	>	* {@code e2} are <em>equal</em> if {@code Objects.equals(e1, e2)}.)
1067	>	* In other words, two Lists are defined to be
1068		* equal if they contain the same elements in the same order.
1069		*
1070		* @param o the Object to be compared for equality with this Vector
#	Line 982 | Line 1103 | public class Vector<E>
1103		* instead of a whole List.  For example, the following idiom
1104		* removes a range of elements from a List:
1105		* <pre>
1106	<	*      list.subList(from, to).clear();
1106	>	*      list.subList(from, to).clear();
1107		* </pre>
1108		* Similar idioms may be constructed for indexOf and lastIndexOf,
1109		* and all of the algorithms in the Collections class can be applied to
#	Line 1000 | Line 1121 | public class Vector<E>
1121		* @throws IndexOutOfBoundsException if an endpoint index value is out of range
1122		*         {@code (fromIndex < 0 || toIndex > size)}
1123		* @throws IllegalArgumentException if the endpoint indices are out of order
1124	<	*         {@code (fromIndex > toIndex)}
1124	>	*         {@code (fromIndex > toIndex)}
1125		*/
1126		public synchronized List<E> subList(int fromIndex, int toIndex) {
1127		return Collections.synchronizedList(super.subList(fromIndex, toIndex),
#	Line 1015 | Line 1136 | public class Vector<E>
1136		* (If {@code toIndex==fromIndex}, this operation has no effect.)
1137		*/
1138		protected synchronized void removeRange(int fromIndex, int toIndex) {
1139	<	modCount++;
1140	<	int numMoved = elementCount - toIndex;
1141	<	System.arraycopy(elementData, toIndex, elementData, fromIndex,
1142	<	numMoved);
1143	<
1144	<	// Let gc do its work
1145	<	int newElementCount = elementCount - (toIndex-fromIndex);
1146	<	while (elementCount != newElementCount)
1147	<	elementData[--elementCount] = null;
1139	>	modCount++;
1140	>	shiftTailOverGap(elementData, fromIndex, toIndex);
1141	>	// checkInvariants();
1142	>	}
1143	>
1144	>	/** Erases the gap from lo to hi, by sliding down following elements. */
1145	>	private void shiftTailOverGap(Object[] es, int lo, int hi) {
1146	>	System.arraycopy(es, hi, es, lo, elementCount - hi);
1147	>	for (int to = elementCount, i = (elementCount -= hi - lo); i < to; i++)
1148	>	es[i] = null;
1149		}
1150
1151		/**
1152	<	* Save the state of the {@code Vector} instance to a stream (that
1153	<	* is, serialize it).  This method is present merely for synchronization.
1154	<	* It just calls the default writeObject method.
1155	<	*/
1156	<	private synchronized void writeObject(java.io.ObjectOutputStream s)
1157	<	throws java.io.IOException
1158	<	{
1159	<	s.defaultWriteObject();
1152	>	* Loads a {@code Vector} instance from a stream
1153	>	* (that is, deserializes it).
1154	>	* This method performs checks to ensure the consistency
1155	>	* of the fields.
1156	>	*
1157	>	* @param in the stream
1158	>	* @throws java.io.IOException if an I/O error occurs
1159	>	* @throws ClassNotFoundException if the stream contains data
1160	>	*         of a non-existing class
1161	>	*/
1162	>	// OPENJDK @java.io.Serial
1163	>	private void readObject(ObjectInputStream in)
1164	>	throws IOException, ClassNotFoundException {
1165	>	ObjectInputStream.GetField gfields = in.readFields();
1166	>	int count = gfields.get("elementCount", 0);
1167	>	Object[] data = (Object[])gfields.get("elementData", null);
1168	>	if (count < 0 || data == null || count > data.length) {
1169	>	throw new StreamCorruptedException("Inconsistent vector internals");
1170	>	}
1171	>	elementCount = count;
1172	>	elementData = data.clone();
1173	>	}
1174	>
1175	>	/**
1176	>	* Saves the state of the {@code Vector} instance to a stream
1177	>	* (that is, serializes it).
1178	>	* This method performs synchronization to ensure the consistency
1179	>	* of the serialized data.
1180	>	*
1181	>	* @param s the stream
1182	>	* @throws java.io.IOException if an I/O error occurs
1183	>	*/
1184	>	// OPENJDK @java.io.Serial
1185	>	private void writeObject(java.io.ObjectOutputStream s)
1186	>	throws java.io.IOException {
1187	>	final java.io.ObjectOutputStream.PutField fields = s.putFields();
1188	>	final Object[] data;
1189	>	synchronized (this) {
1190	>	fields.put("capacityIncrement", capacityIncrement);
1191	>	fields.put("elementCount", elementCount);
1192	>	data = elementData.clone();
1193	>	}
1194	>	fields.put("elementData", data);
1195	>	s.writeFields();
1196		}
1197
1198		/**
#	Line 1050 | Line 1208 | public class Vector<E>
1208		* @throws IndexOutOfBoundsException {@inheritDoc}
1209		*/
1210		public synchronized ListIterator<E> listIterator(int index) {
1211	<	if (index < 0 || index > elementCount)
1211	>	if (index < 0 || index > elementCount)
1212		throw new IndexOutOfBoundsException("Index: "+index);
1213	<	return new ListItr(index);
1213	>	return new ListItr(index);
1214		}
1215
1216		/**
#	Line 1064 | Line 1222 | public class Vector<E>
1222		* @see #listIterator(int)
1223		*/
1224		public synchronized ListIterator<E> listIterator() {
1225	<	return new ListItr(0);
1225	>	return new ListItr(0);
1226		}
1227
1228		/**
#	Line 1075 | Line 1233 | public class Vector<E>
1233		* @return an iterator over the elements in this list in proper sequence
1234		*/
1235		public synchronized Iterator<E> iterator() {
1236	<	return new Itr();
1236	>	return new Itr();
1237		}
1238
1239		/**
1240		* An optimized version of AbstractList.Itr
1241		*/
1242		private class Itr implements Iterator<E> {
1243	<	int cursor;       // index of next element to return
1244	<	int lastRet = -1; // index of last element returned; -1 if no such
1245	<	int expectedModCount = modCount;
1243	>	int cursor;       // index of next element to return
1244	>	int lastRet = -1; // index of last element returned; -1 if no such
1245	>	int expectedModCount = modCount;
1246
1247	<	public boolean hasNext() {
1247	>	public boolean hasNext() {
1248		// Racy but within spec, since modifications are checked
1249		// within or after synchronization in next/previous
1250		return cursor != elementCount;
1251	<	}
1251	>	}
1252	>
1253	>	public E next() {
1254	>	synchronized (Vector.this) {
1255	>	checkForComodification();
1256	>	int i = cursor;
1257	>	if (i >= elementCount)
1258	>	throw new NoSuchElementException();
1259	>	cursor = i + 1;
1260	>	return elementData(lastRet = i);
1261	>	}
1262	>	}
1263
1264	<	public E next() {
1265	<	synchronized (Vector.this) {
1266	<	checkForComodification();
1267	<	int i = cursor;
1268	<	if (i >= elementCount)
1269	<	throw new NoSuchElementException();
1270	<	cursor = i + 1;
1102	<	return elementData(lastRet = i);
1103	<	}
1104	<	}
1105	<
1106	<	public void remove() {
1107	<	if (lastRet == -1)
1108	<	throw new IllegalStateException();
1109	<	synchronized (Vector.this) {
1110	<	checkForComodification();
1111	<	Vector.this.remove(lastRet);
1112	<	expectedModCount = modCount;
1264	>	public void remove() {
1265	>	if (lastRet == -1)
1266	>	throw new IllegalStateException();
1267	>	synchronized (Vector.this) {
1268	>	checkForComodification();
1269	>	Vector.this.remove(lastRet);
1270	>	expectedModCount = modCount;
1271		}
1272	<	cursor = lastRet;
1273	<	lastRet = -1;
1274	<	}
1275	<
1276	<	final void checkForComodification() {
1277	<	if (modCount != expectedModCount)
1278	<	throw new ConcurrentModificationException();
1279	<	}
1272	>	cursor = lastRet;
1273	>	lastRet = -1;
1274	>	}
1275	>
1276	>	@Override
1277	>	public void forEachRemaining(Consumer<? super E> action) {
1278	>	Objects.requireNonNull(action);
1279	>	synchronized (Vector.this) {
1280	>	final int size = elementCount;
1281	>	int i = cursor;
1282	>	if (i >= size) {
1283	>	return;
1284	>	}
1285	>	final Object[] es = elementData;
1286	>	if (i >= es.length)
1287	>	throw new ConcurrentModificationException();
1288	>	while (i < size && modCount == expectedModCount)
1289	>	action.accept(elementAt(es, i++));
1290	>	// update once at end of iteration to reduce heap write traffic
1291	>	cursor = i;
1292	>	lastRet = i - 1;
1293	>	checkForComodification();
1294	>	}
1295	>	}
1296	>
1297	>	final void checkForComodification() {
1298	>	if (modCount != expectedModCount)
1299	>	throw new ConcurrentModificationException();
1300	>	}
1301		}
1302
1303		/**
1304		* An optimized version of AbstractList.ListItr
1305		*/
1306		final class ListItr extends Itr implements ListIterator<E> {
1307	<	ListItr(int index) {
1308	<	super();
1309	<	cursor = index;
1310	<	}
1311	<
1312	<	public boolean hasPrevious() {
1313	<	return cursor != 0;
1314	<	}
1315	<
1316	<	public int nextIndex() {
1317	<	return cursor;
1318	<	}
1319	<
1320	<	public int previousIndex() {
1321	<	return cursor - 1;
1322	<	}
1323	<
1324	<	public E previous() {
1325	<	synchronized (Vector.this) {
1326	<	checkForComodification();
1327	<	int i = cursor - 1;
1328	<	if (i < 0)
1329	<	throw new NoSuchElementException();
1330	<	cursor = i;
1331	<	return elementData(lastRet = i);
1332	<	}
1333	<	}
1334	<
1335	<	public void set(E e) {
1336	<	if (lastRet == -1)
1337	<	throw new IllegalStateException();
1338	<	synchronized (Vector.this) {
1339	<	checkForComodification();
1340	<	Vector.this.set(lastRet, e);
1341	<	}
1342	<	}
1343	<
1344	<	public void add(E e) {
1345	<	int i = cursor;
1346	<	synchronized (Vector.this) {
1347	<	checkForComodification();
1348	<	Vector.this.add(i, e);
1349	<	expectedModCount = modCount;
1350	<	}
1351	<	cursor = i + 1;
1352	<	lastRet = -1;
1353	<	}
1307	>	ListItr(int index) {
1308	>	super();
1309	>	cursor = index;
1310	>	}
1311	>
1312	>	public boolean hasPrevious() {
1313	>	return cursor != 0;
1314	>	}
1315	>
1316	>	public int nextIndex() {
1317	>	return cursor;
1318	>	}
1319	>
1320	>	public int previousIndex() {
1321	>	return cursor - 1;
1322	>	}
1323	>
1324	>	public E previous() {
1325	>	synchronized (Vector.this) {
1326	>	checkForComodification();
1327	>	int i = cursor - 1;
1328	>	if (i < 0)
1329	>	throw new NoSuchElementException();
1330	>	cursor = i;
1331	>	return elementData(lastRet = i);
1332	>	}
1333	>	}
1334	>
1335	>	public void set(E e) {
1336	>	if (lastRet == -1)
1337	>	throw new IllegalStateException();
1338	>	synchronized (Vector.this) {
1339	>	checkForComodification();
1340	>	Vector.this.set(lastRet, e);
1341	>	}
1342	>	}
1343	>
1344	>	public void add(E e) {
1345	>	int i = cursor;
1346	>	synchronized (Vector.this) {
1347	>	checkForComodification();
1348	>	Vector.this.add(i, e);
1349	>	expectedModCount = modCount;
1350	>	}
1351	>	cursor = i + 1;
1352	>	lastRet = -1;
1353	>	}
1354	>	}
1355	>
1356	>	/**
1357	>	* @throws NullPointerException {@inheritDoc}
1358	>	*/
1359	>	@Override
1360	>	public synchronized void forEach(Consumer<? super E> action) {
1361	>	Objects.requireNonNull(action);
1362	>	final int expectedModCount = modCount;
1363	>	final Object[] es = elementData;
1364	>	final int size = elementCount;
1365	>	for (int i = 0; modCount == expectedModCount && i < size; i++)
1366	>	action.accept(elementAt(es, i));
1367	>	if (modCount != expectedModCount)
1368	>	throw new ConcurrentModificationException();
1369	>	// checkInvariants();
1370	>	}
1371	>
1372	>	/**
1373	>	* @throws NullPointerException {@inheritDoc}
1374	>	*/
1375	>	@Override
1376	>	public synchronized void replaceAll(UnaryOperator<E> operator) {
1377	>	Objects.requireNonNull(operator);
1378	>	final int expectedModCount = modCount;
1379	>	final Object[] es = elementData;
1380	>	final int size = elementCount;
1381	>	for (int i = 0; modCount == expectedModCount && i < size; i++)
1382	>	es[i] = operator.apply(elementAt(es, i));
1383	>	if (modCount != expectedModCount)
1384	>	throw new ConcurrentModificationException();
1385	>	// TODO(8203662): remove increment of modCount from ...
1386	>	modCount++;
1387	>	// checkInvariants();
1388	>	}
1389	>
1390	>	@SuppressWarnings("unchecked")
1391	>	@Override
1392	>	public synchronized void sort(Comparator<? super E> c) {
1393	>	final int expectedModCount = modCount;
1394	>	Arrays.sort((E[]) elementData, 0, elementCount, c);
1395	>	if (modCount != expectedModCount)
1396	>	throw new ConcurrentModificationException();
1397	>	modCount++;
1398	>	// checkInvariants();
1399	>	}
1400	>
1401	>	/**
1402	>	* Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
1403	>	* and <em>fail-fast</em> {@link Spliterator} over the elements in this
1404	>	* list.
1405	>	*
1406	>	* <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
1407	>	* {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
1408	>	* Overriding implementations should document the reporting of additional
1409	>	* characteristic values.
1410	>	*
1411	>	* @return a {@code Spliterator} over the elements in this list
1412	>	* @since 1.8
1413	>	*/
1414	>	@Override
1415	>	public Spliterator<E> spliterator() {
1416	>	return new VectorSpliterator(null, 0, -1, 0);
1417	>	}
1418	>
1419	>	/** Similar to ArrayList Spliterator */
1420	>	final class VectorSpliterator implements Spliterator<E> {
1421	>	private Object[] array;
1422	>	private int index; // current index, modified on advance/split
1423	>	private int fence; // -1 until used; then one past last index
1424	>	private int expectedModCount; // initialized when fence set
1425	>
1426	>	/** Creates new spliterator covering the given range. */
1427	>	VectorSpliterator(Object[] array, int origin, int fence,
1428	>	int expectedModCount) {
1429	>	this.array = array;
1430	>	this.index = origin;
1431	>	this.fence = fence;
1432	>	this.expectedModCount = expectedModCount;
1433	>	}
1434	>
1435	>	private int getFence() { // initialize on first use
1436	>	int hi;
1437	>	if ((hi = fence) < 0) {
1438	>	synchronized (Vector.this) {
1439	>	array = elementData;
1440	>	expectedModCount = modCount;
1441	>	hi = fence = elementCount;
1442	>	}
1443	>	}
1444	>	return hi;
1445	>	}
1446	>
1447	>	public Spliterator<E> trySplit() {
1448	>	int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1449	>	return (lo >= mid) ? null :
1450	>	new VectorSpliterator(array, lo, index = mid, expectedModCount);
1451	>	}
1452	>
1453	>	@SuppressWarnings("unchecked")
1454	>	public boolean tryAdvance(Consumer<? super E> action) {
1455	>	Objects.requireNonNull(action);
1456	>	int i;
1457	>	if (getFence() > (i = index)) {
1458	>	index = i + 1;
1459	>	action.accept((E)array[i]);
1460	>	if (modCount != expectedModCount)
1461	>	throw new ConcurrentModificationException();
1462	>	return true;
1463	>	}
1464	>	return false;
1465	>	}
1466	>
1467	>	@SuppressWarnings("unchecked")
1468	>	public void forEachRemaining(Consumer<? super E> action) {
1469	>	Objects.requireNonNull(action);
1470	>	final int hi = getFence();
1471	>	final Object[] a = array;
1472	>	int i;
1473	>	for (i = index, index = hi; i < hi; i++)
1474	>	action.accept((E) a[i]);
1475	>	if (modCount != expectedModCount)
1476	>	throw new ConcurrentModificationException();
1477	>	}
1478	>
1479	>	public long estimateSize() {
1480	>	return getFence() - index;
1481	>	}
1482	>
1483	>	public int characteristics() {
1484	>	return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
1485	>	}
1486	>	}
1487	>
1488	>	void checkInvariants() {
1489	>	// assert elementCount >= 0;
1490	>	// assert elementCount == elementData.length || elementData[elementCount] == null;
1491		}
1492		}

Diff Legend

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