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.23 by jsr166, Sun May 18 23:47:56 2008 UTC vs.
Revision 1.44 by jsr166, Sat Dec 24 19:32:07 2016 UTC

#	Line 1 | Line 1
1		/*
2	<	* Copyright 1994-2007 Sun Microsystems, Inc.  All Rights Reserved.
2	>	* Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
3		* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4		*
5		* 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.util.function.Consumer;
29	+	import java.util.function.Predicate;
30	+	import java.util.function.UnaryOperator;
31	+
32		/**
33		* The {@code Vector} class implements a growable array of
34		* objects. Like an array, it contains components that can be
#	Line 41 | Line 45 | package java.util;
45		* capacity of a vector before inserting a large number of
46		* components; this reduces the amount of incremental reallocation.
47		*
48	<	* <p><a name="fail-fast"/>
48	>	* <p id="fail-fast">
49		* The iterators returned by this class's {@link #iterator() iterator} and
50		* {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
51		* if the vector is structurally modified at any time after the iterator is
#	Line 52 | Line 56 | package java.util;
56		* concurrent modification, the iterator fails quickly and cleanly, rather
57		* than risking arbitrary, non-deterministic behavior at an undetermined
58		* time in the future.  The {@link Enumeration Enumerations} returned by
59	<	* the {@link #elements() elements} method are <em>not</em> fail-fast.
59	>	* the {@link #elements() elements} method are <em>not</em> fail-fast; if the
60	>	* Vector is structurally modified at any time after the enumeration is
61	>	* created then the results of enumerating are undefined.
62		*
63		* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
64		* as it is, generally speaking, impossible to make any hard guarantees in the
#	Line 64 | Line 70 | package java.util;
70		*
71		* <p>As of the Java 2 platform v1.2, this class was retrofitted to
72		* implement the {@link List} interface, making it a member of the
73	<	* <a href="{@docRoot}/../technotes/guides/collections/index.html"> Java
74	<	* Collections Framework</a>.  Unlike the new collection
75	<	* implementations, {@code Vector} is synchronized.
73	>	* <a href="{@docRoot}/../technotes/guides/collections/index.html">
74	>	* Java Collections Framework</a>.  Unlike the new collection
75	>	* implementations, {@code Vector} is synchronized.  If a thread-safe
76	>	* implementation is not needed, it is recommended to use {@link
77	>	* ArrayList} in place of {@code Vector}.
78	>	*
79	>	* @param <E> Type of component elements
80		*
81		* @author  Lee Boynton
82		* @author  Jonathan Payne
73	–	* @version %I%, %G%
83		* @see Collection
75	–	* @see List
76	–	* @see ArrayList
84		* @see LinkedList
85	<	* @since   JDK1.0
85	>	* @since   1.0
86		*/
87		public class Vector<E>
88		extends AbstractList<E>
#	Line 167 | Line 174 | public class Vector<E>
174		public Vector(Collection<? extends E> c) {
175		elementData = c.toArray();
176		elementCount = elementData.length;
177	<	// c.toArray might (incorrectly) not return Object[] (see 6260652)
177	>	// defend against c.toArray (incorrectly) not returning Object[]
178	>	// (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
179		if (elementData.getClass() != Object[].class)
180		elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
181		}
#	Line 223 | Line 231 | public class Vector<E>
231		* @param minCapacity the desired minimum capacity
232		*/
233		public synchronized void ensureCapacity(int minCapacity) {
234	<	modCount++;
235	<	ensureCapacityHelper(minCapacity);
234	>	if (minCapacity > 0) {
235	>	modCount++;
236	>	if (minCapacity > elementData.length)
237	>	grow(minCapacity);
238	>	}
239		}
240
241		/**
242	<	* This implements the unsynchronized semantics of ensureCapacity.
243	<	* Synchronized methods in this class can internally call this
244	<	* method for ensuring capacity without incurring the cost of an
245	<	* extra synchronization.
242	>	* The maximum size of array to allocate (unless necessary).
243	>	* Some VMs reserve some header words in an array.
244	>	* Attempts to allocate larger arrays may result in
245	>	* OutOfMemoryError: Requested array size exceeds VM limit
246	>	*/
247	>	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
248	>
249	>	/**
250	>	* Increases the capacity to ensure that it can hold at least the
251	>	* number of elements specified by the minimum capacity argument.
252		*
253	<	* @see #ensureCapacity(int)
253	>	* @param minCapacity the desired minimum capacity
254	>	* @throws OutOfMemoryError if minCapacity is less than zero
255		*/
256	<	private void ensureCapacityHelper(int minCapacity) {
256	>	private Object[] grow(int minCapacity) {
257	>	return elementData = Arrays.copyOf(elementData,
258	>	newCapacity(minCapacity));
259	>	}
260	>
261	>	private Object[] grow() {
262	>	return grow(elementCount + 1);
263	>	}
264	>
265	>	/**
266	>	* Returns a capacity at least as large as the given minimum capacity.
267	>	* Will not return a capacity greater than MAX_ARRAY_SIZE unless
268	>	* the given minimum capacity is greater than MAX_ARRAY_SIZE.
269	>	*
270	>	* @param minCapacity the desired minimum capacity
271	>	* @throws OutOfMemoryError if minCapacity is less than zero
272	>	*/
273	>	private int newCapacity(int minCapacity) {
274	>	// overflow-conscious code
275		int oldCapacity = elementData.length;
276	<	if (minCapacity > oldCapacity) {
277	<	Object[] oldData = elementData;
278	<	int newCapacity = (capacityIncrement > 0) ?
279	<	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
280	<	if (newCapacity < minCapacity) {
281	<	newCapacity = minCapacity;
282	<	}
283	<	elementData = Arrays.copyOf(elementData, newCapacity);
284	<	}
276	>	int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
277	>	capacityIncrement : oldCapacity);
278	>	if (newCapacity - minCapacity <= 0) {
279	>	if (minCapacity < 0) // overflow
280	>	throw new OutOfMemoryError();
281	>	return minCapacity;
282	>	}
283	>	return (newCapacity - MAX_ARRAY_SIZE <= 0)
284	>	? newCapacity
285	>	: hugeCapacity(minCapacity);
286	>	}
287	>
288	>	private static int hugeCapacity(int minCapacity) {
289	>	if (minCapacity < 0) // overflow
290	>	throw new OutOfMemoryError();
291	>	return (minCapacity > MAX_ARRAY_SIZE) ?
292	>	Integer.MAX_VALUE :
293	>	MAX_ARRAY_SIZE;
294		}
295
296		/**
#	Line 259 | Line 304 | public class Vector<E>
304		*/
305		public synchronized void setSize(int newSize) {
306		modCount++;
307	<	if (newSize > elementCount) {
308	<	ensureCapacityHelper(newSize);
309	<	} else {
310	<	for (int i = newSize ; i < elementCount ; i++) {
311	<	elementData[i] = null;
267	<	}
268	<	}
269	<	elementCount = newSize;
307	>	if (newSize > elementData.length)
308	>	grow(newSize);
309	>	final Object[] es = elementData;
310	>	for (int to = elementCount, i = elementCount = newSize; i < to; i++)
311	>	es[i] = null;
312		}
313
314		/**
#	Line 304 | Line 346 | public class Vector<E>
346		* Returns an enumeration of the components of this vector. The
347		* returned {@code Enumeration} object will generate all items in
348		* this vector. The first item generated is the item at index {@code 0},
349	<	* then the item at index {@code 1}, and so on.
349	>	* then the item at index {@code 1}, and so on. If the vector is
350	>	* structurally modified while enumerating over the elements then the
351	>	* results of enumerating are undefined.
352		*
353		* @return  an enumeration of the components of this vector
354		* @see     Iterator
#	Line 332 | Line 376 | public class Vector<E>
376		* Returns {@code true} if this vector contains the specified element.
377		* More formally, returns {@code true} if and only if this vector
378		* contains at least one element {@code e} such that
379	<	* <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
379	>	* {@code Objects.equals(o, e)}.
380		*
381		* @param o element whose presence in this vector is to be tested
382		* @return {@code true} if this vector contains the specified element
#	Line 345 | Line 389 | public class Vector<E>
389		* Returns the index of the first occurrence of the specified element
390		* in this vector, or -1 if this vector does not contain the element.
391		* More formally, returns the lowest index {@code i} such that
392	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
392	>	* {@code Objects.equals(o, get(i))},
393		* or -1 if there is no such index.
394		*
395		* @param o element to search for
#	Line 361 | Line 405 | public class Vector<E>
405		* this vector, searching forwards from {@code index}, or returns -1 if
406		* the element is not found.
407		* More formally, returns the lowest index {@code i} such that
408	<	* <tt>(i&nbsp;&gt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
408	>	* {@code (i >= index && Objects.equals(o, get(i)))},
409		* or -1 if there is no such index.
410		*
411		* @param o element to search for
#	Line 389 | Line 433 | public class Vector<E>
433		* Returns the index of the last occurrence of the specified element
434		* in this vector, or -1 if this vector does not contain the element.
435		* More formally, returns the highest index {@code i} such that
436	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
436	>	* {@code Objects.equals(o, get(i))},
437		* or -1 if there is no such index.
438		*
439		* @param o element to search for
#	Line 405 | Line 449 | public class Vector<E>
449		* this vector, searching backwards from {@code index}, or returns -1 if
450		* the element is not found.
451		* More formally, returns the highest index {@code i} such that
452	<	* <tt>(i&nbsp;&lt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
452	>	* {@code (i <= index && Objects.equals(o, get(i)))},
453		* or -1 if there is no such index.
454		*
455		* @param o element to search for
#	Line 469 | Line 513 | public class Vector<E>
513		* Returns the last component of the vector.
514		*
515		* @return  the last component of the vector, i.e., the component at index
516	<	*          <code>size()&nbsp;-&nbsp;1</code>.
516	>	*          {@code size() - 1}
517		* @throws NoSuchElementException if this vector is empty
518		*/
519		public synchronized E lastElement() {
#	Line 527 | Line 571 | public class Vector<E>
571		*         ({@code index < 0 || index >= size()})
572		*/
573		public synchronized void removeElementAt(int index) {
530	–	modCount++;
574		if (index >= elementCount) {
575		throw new ArrayIndexOutOfBoundsException(index + " >= " +
576		elementCount);
#	Line 539 | Line 582 | public class Vector<E>
582		if (j > 0) {
583		System.arraycopy(elementData, index + 1, elementData, index, j);
584		}
585	+	modCount++;
586		elementCount--;
587		elementData[elementCount] = null; /* to let gc do its work */
588	+	// checkInvariants();
589		}
590
591		/**
#	Line 567 | Line 612 | public class Vector<E>
612		*         ({@code index < 0 || index > size()})
613		*/
614		public synchronized void insertElementAt(E obj, int index) {
570	–	modCount++;
615		if (index > elementCount) {
616		throw new ArrayIndexOutOfBoundsException(index
617		+ " > " + elementCount);
618		}
619	<	ensureCapacityHelper(elementCount + 1);
620	<	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
619	>	modCount++;
620	>	final int s = elementCount;
621	>	Object[] elementData = this.elementData;
622	>	if (s == elementData.length)
623	>	elementData = grow();
624	>	System.arraycopy(elementData, index,
625	>	elementData, index + 1,
626	>	s - index);
627		elementData[index] = obj;
628	<	elementCount++;
628	>	elementCount = s + 1;
629		}
630
631		/**
#	Line 591 | Line 641 | public class Vector<E>
641		*/
642		public synchronized void addElement(E obj) {
643		modCount++;
644	<	ensureCapacityHelper(elementCount + 1);
595	<	elementData[elementCount++] = obj;
644	>	add(obj, elementData, elementCount);
645		}
646
647		/**
#	Line 627 | Line 676 | public class Vector<E>
676		* method (which is part of the {@link List} interface).
677		*/
678		public synchronized void removeAllElements() {
679	+	final Object[] es = elementData;
680	+	for (int to = elementCount, i = elementCount = 0; i < to; i++)
681	+	es[i] = null;
682		modCount++;
631	–	// Let gc do its work
632	–	for (int i = 0; i < elementCount; i++)
633	–	elementData[i] = null;
634	–
635	–	elementCount = 0;
683		}
684
685		/**
#	Line 645 | Line 692 | public class Vector<E>
692		public synchronized Object clone() {
693		try {
694		@SuppressWarnings("unchecked")
695	<	Vector<E> v = (Vector<E>) super.clone();
695	>	Vector<E> v = (Vector<E>) super.clone();
696		v.elementData = Arrays.copyOf(elementData, elementCount);
697		v.modCount = 0;
698		return v;
699		} catch (CloneNotSupportedException e) {
700		// this shouldn't happen, since we are Cloneable
701	<	throw new InternalError();
701	>	throw new InternalError(e);
702		}
703		}
704
#	Line 679 | Line 726 | public class Vector<E>
726		* of the Vector <em>only</em> if the caller knows that the Vector
727		* does not contain any null elements.)
728		*
729	+	* @param <T> type of array elements. The same type as {@code <E>} or a
730	+	* supertype of {@code <E>}.
731		* @param a the array into which the elements of the Vector are to
732		*          be stored, if it is big enough; otherwise, a new array of the
733		*          same runtime type is allocated for this purpose.
734		* @return an array containing the elements of the Vector
735	<	* @throws ArrayStoreException if the runtime type of a is not a supertype
736	<	* of the runtime type of every element in this Vector
735	>	* @throws ArrayStoreException if the runtime type of a, {@code <T>}, is not
736	>	* a supertype of the runtime type, {@code <E>}, of every element in this
737	>	* Vector
738		* @throws NullPointerException if the given array is null
739		* @since 1.2
740		*/
#	Line 708 | Line 758 | public class Vector<E>
758		return (E) elementData[index];
759		}
760
761	+	@SuppressWarnings("unchecked")
762	+	static <E> E elementAt(Object[] es, int index) {
763	+	return (E) es[index];
764	+	}
765	+
766		/**
767		* Returns the element at the specified position in this Vector.
768		*
#	Line 745 | Line 800 | public class Vector<E>
800		}
801
802		/**
803	+	* This helper method split out from add(E) to keep method
804	+	* bytecode size under 35 (the -XX:MaxInlineSize default value),
805	+	* which helps when add(E) is called in a C1-compiled loop.
806	+	*/
807	+	private void add(E e, Object[] elementData, int s) {
808	+	if (s == elementData.length)
809	+	elementData = grow();
810	+	elementData[s] = e;
811	+	elementCount = s + 1;
812	+	// checkInvariants();
813	+	}
814	+
815	+	/**
816		* Appends the specified element to the end of this Vector.
817		*
818		* @param e element to be appended to this Vector
#	Line 753 | Line 821 | public class Vector<E>
821		*/
822		public synchronized boolean add(E e) {
823		modCount++;
824	<	ensureCapacityHelper(elementCount + 1);
757	<	elementData[elementCount++] = e;
824	>	add(e, elementData, elementCount);
825		return true;
826		}
827
#	Line 762 | Line 829 | public class Vector<E>
829		* Removes the first occurrence of the specified element in this Vector
830		* If the Vector does not contain the element, it is unchanged.  More
831		* formally, removes the element with the lowest index i such that
832	<	* {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
832	>	* {@code Objects.equals(o, get(i))} (if such
833		* an element exists).
834		*
835		* @param o element to be removed from this Vector, if present
#	Line 793 | Line 860 | public class Vector<E>
860		* Shifts any subsequent elements to the left (subtracts one from their
861		* indices).  Returns the element that was removed from the Vector.
862		*
796	–	* @throws ArrayIndexOutOfBoundsException if the index is out of range
797	–	*         ({@code index < 0 || index >= size()})
863		* @param index the index of the element to be removed
864		* @return element that was removed
865	+	* @throws ArrayIndexOutOfBoundsException if the index is out of range
866	+	*         ({@code index < 0 || index >= size()})
867		* @since 1.2
868		*/
869		public synchronized E remove(int index) {
#	Line 811 | Line 878 | public class Vector<E>
878		numMoved);
879		elementData[--elementCount] = null; // Let gc do its work
880
881	+	// checkInvariants();
882		return oldValue;
883		}
884
#	Line 853 | Line 921 | public class Vector<E>
921		* @throws NullPointerException if the specified collection is null
922		* @since 1.2
923		*/
924	<	public synchronized boolean addAll(Collection<? extends E> c) {
857	<	modCount++;
924	>	public boolean addAll(Collection<? extends E> c) {
925		Object[] a = c.toArray();
926	+	modCount++;
927		int numNew = a.length;
928	<	ensureCapacityHelper(elementCount + numNew);
929	<	System.arraycopy(a, 0, elementData, elementCount, numNew);
930	<	elementCount += numNew;
931	<	return numNew != 0;
928	>	if (numNew == 0)
929	>	return false;
930	>	synchronized (this) {
931	>	Object[] elementData = this.elementData;
932	>	final int s = elementCount;
933	>	if (numNew > elementData.length - s)
934	>	elementData = grow(s + numNew);
935	>	System.arraycopy(a, 0, elementData, s, numNew);
936	>	elementCount = s + numNew;
937	>	// checkInvariants();
938	>	return true;
939	>	}
940		}
941
942		/**
#	Line 871 | Line 947 | public class Vector<E>
947		* @return true if this Vector changed as a result of the call
948		* @throws ClassCastException if the types of one or more elements
949		*         in this vector are incompatible with the specified
950	<	*         collection (optional)
950	>	*         collection
951	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
952		* @throws NullPointerException if this vector contains one or more null
953		*         elements and the specified collection does not support null
954	<	*         elements (optional), or if the specified collection is null
954	>	*         elements
955	>	* (<a href="Collection.html#optional-restrictions">optional</a>),
956	>	*         or if the specified collection is null
957		* @since 1.2
958		*/
959	<	public synchronized boolean removeAll(Collection<?> c) {
960	<	return super.removeAll(c);
959	>	public boolean removeAll(Collection<?> c) {
960	>	Objects.requireNonNull(c);
961	>	return bulkRemove(e -> c.contains(e));
962		}
963
964		/**
#	Line 891 | Line 971 | public class Vector<E>
971		* @return true if this Vector changed as a result of the call
972		* @throws ClassCastException if the types of one or more elements
973		*         in this vector are incompatible with the specified
974	<	*         collection (optional)
974	>	*         collection
975	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
976		* @throws NullPointerException if this vector contains one or more null
977		*         elements and the specified collection does not support null
978	<	*         elements (optional), or if the specified collection is null
978	>	*         elements
979	>	*         (<a href="Collection.html#optional-restrictions">optional</a>),
980	>	*         or if the specified collection is null
981		* @since 1.2
982		*/
983	<	public synchronized boolean retainAll(Collection<?> c)  {
984	<	return super.retainAll(c);
983	>	public boolean retainAll(Collection<?> c) {
984	>	Objects.requireNonNull(c);
985	>	return bulkRemove(e -> !c.contains(e));
986	>	}
987	>
988	>	/**
989	>	* @throws NullPointerException {@inheritDoc}
990	>	*/
991	>	@Override
992	>	public boolean removeIf(Predicate<? super E> filter) {
993	>	Objects.requireNonNull(filter);
994	>	return bulkRemove(filter);
995	>	}
996	>
997	>	// A tiny bit set implementation
998	>
999	>	private static long[] nBits(int n) {
1000	>	return new long[((n - 1) >> 6) + 1];
1001	>	}
1002	>	private static void setBit(long[] bits, int i) {
1003	>	bits[i >> 6] |= 1L << i;
1004	>	}
1005	>	private static boolean isClear(long[] bits, int i) {
1006	>	return (bits[i >> 6] & (1L << i)) == 0;
1007	>	}
1008	>
1009	>	private synchronized boolean bulkRemove(Predicate<? super E> filter) {
1010	>	int expectedModCount = modCount;
1011	>	final Object[] es = elementData;
1012	>	final int end = elementCount;
1013	>	int i;
1014	>	// Optimize for initial run of survivors
1015	>	for (i = 0; i < end && !filter.test(elementAt(es, i)); i++)
1016	>	;
1017	>	// Tolerate predicates that reentrantly access the collection for
1018	>	// read (but writers still get CME), so traverse once to find
1019	>	// elements to delete, a second pass to physically expunge.
1020	>	if (i < end) {
1021	>	final int beg = i;
1022	>	final long[] deathRow = nBits(end - beg);
1023	>	deathRow[0] = 1L;   // set bit 0
1024	>	for (i = beg + 1; i < end; i++)
1025	>	if (filter.test(elementAt(es, i)))
1026	>	setBit(deathRow, i - beg);
1027	>	if (modCount != expectedModCount)
1028	>	throw new ConcurrentModificationException();
1029	>	expectedModCount++;
1030	>	modCount++;
1031	>	int w = beg;
1032	>	for (i = beg; i < end; i++)
1033	>	if (isClear(deathRow, i - beg))
1034	>	es[w++] = es[i];
1035	>	for (i = elementCount = w; i < end; i++)
1036	>	es[i] = null;
1037	>	// checkInvariants();
1038	>	return true;
1039	>	} else {
1040	>	if (modCount != expectedModCount)
1041	>	throw new ConcurrentModificationException();
1042	>	// checkInvariants();
1043	>	return false;
1044	>	}
1045		}
1046
1047		/**
#	Line 919 | Line 1062 | public class Vector<E>
1062		* @since 1.2
1063		*/
1064		public synchronized boolean addAll(int index, Collection<? extends E> c) {
922	–	modCount++;
1065		if (index < 0 || index > elementCount)
1066		throw new ArrayIndexOutOfBoundsException(index);
1067
1068		Object[] a = c.toArray();
1069	+	modCount++;
1070		int numNew = a.length;
1071	<	ensureCapacityHelper(elementCount + numNew);
1071	>	if (numNew == 0)
1072	>	return false;
1073	>	Object[] elementData = this.elementData;
1074	>	final int s = elementCount;
1075	>	if (numNew > elementData.length - s)
1076	>	elementData = grow(s + numNew);
1077
1078	<	int numMoved = elementCount - index;
1078	>	int numMoved = s - index;
1079		if (numMoved > 0)
1080	<	System.arraycopy(elementData, index, elementData, index + numNew,
1080	>	System.arraycopy(elementData, index,
1081	>	elementData, index + numNew,
1082		numMoved);
934	–
1083		System.arraycopy(a, 0, elementData, index, numNew);
1084	<	elementCount += numNew;
1085	<	return numNew != 0;
1084	>	elementCount = s + numNew;
1085	>	// checkInvariants();
1086	>	return true;
1087		}
1088
1089		/**
#	Line 942 | Line 1091 | public class Vector<E>
1091		* true if and only if the specified Object is also a List, both Lists
1092		* have the same size, and all corresponding pairs of elements in the two
1093		* Lists are <em>equal</em>.  (Two elements {@code e1} and
1094	<	* {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
1095	<	* e1.equals(e2))}.)  In other words, two Lists are defined to be
1094	>	* {@code e2} are <em>equal</em> if {@code Objects.equals(e1, e2)}.)
1095	>	* In other words, two Lists are defined to be
1096		* equal if they contain the same elements in the same order.
1097		*
1098		* @param o the Object to be compared for equality with this Vector
#	Line 1016 | Line 1165 | public class Vector<E>
1165		*/
1166		protected synchronized void removeRange(int fromIndex, int toIndex) {
1167		modCount++;
1168	<	int numMoved = elementCount - toIndex;
1169	<	System.arraycopy(elementData, toIndex, elementData, fromIndex,
1170	<	numMoved);
1168	>	shiftTailOverGap(elementData, fromIndex, toIndex);
1169	>	// checkInvariants();
1170	>	}
1171
1172	<	// Let gc do its work
1173	<	int newElementCount = elementCount - (toIndex-fromIndex);
1174	<	while (elementCount != newElementCount)
1175	<	elementData[--elementCount] = null;
1172	>	/** Erases the gap from lo to hi, by sliding down following elements. */
1173	>	private void shiftTailOverGap(Object[] es, int lo, int hi) {
1174	>	System.arraycopy(es, hi, es, lo, elementCount - hi);
1175	>	for (int to = elementCount, i = (elementCount -= hi - lo); i < to; i++)
1176	>	es[i] = null;
1177		}
1178
1179		/**
1180	<	* Save the state of the {@code Vector} instance to a stream (that
1181	<	* is, serialize it).  This method is present merely for synchronization.
1182	<	* It just calls the default writeObject method.
1180	>	* Saves the state of the {@code Vector} instance to a stream
1181	>	* (that is, serializes it).
1182	>	* This method performs synchronization to ensure the consistency
1183	>	* of the serialized data.
1184	>	*
1185	>	* @param s the stream
1186	>	* @throws java.io.IOException if an I/O error occurs
1187		*/
1188	<	private synchronized void writeObject(java.io.ObjectOutputStream s)
1189	<	throws java.io.IOException
1190	<	{
1191	<	s.defaultWriteObject();
1188	>	private void writeObject(java.io.ObjectOutputStream s)
1189	>	throws java.io.IOException {
1190	>	final java.io.ObjectOutputStream.PutField fields = s.putFields();
1191	>	final Object[] data;
1192	>	synchronized (this) {
1193	>	fields.put("capacityIncrement", capacityIncrement);
1194	>	fields.put("elementCount", elementCount);
1195	>	data = elementData.clone();
1196	>	}
1197	>	fields.put("elementData", data);
1198	>	s.writeFields();
1199		}
1200
1201		/**
#	Line 1115 | Line 1276 | public class Vector<E>
1276		lastRet = -1;
1277		}
1278
1279	+	@Override
1280	+	public void forEachRemaining(Consumer<? super E> action) {
1281	+	Objects.requireNonNull(action);
1282	+	synchronized (Vector.this) {
1283	+	final int size = elementCount;
1284	+	int i = cursor;
1285	+	if (i >= size) {
1286	+	return;
1287	+	}
1288	+	final Object[] es = elementData;
1289	+	if (i >= es.length)
1290	+	throw new ConcurrentModificationException();
1291	+	while (i < size && modCount == expectedModCount)
1292	+	action.accept(elementAt(es, i++));
1293	+	// update once at end of iteration to reduce heap write traffic
1294	+	cursor = i;
1295	+	lastRet = i - 1;
1296	+	checkForComodification();
1297	+	}
1298	+	}
1299	+
1300		final void checkForComodification() {
1301		if (modCount != expectedModCount)
1302		throw new ConcurrentModificationException();
#	Line 1173 | Line 1355 | public class Vector<E>
1355		lastRet = -1;
1356		}
1357		}
1358	+
1359	+	/**
1360	+	* @throws NullPointerException {@inheritDoc}
1361	+	*/
1362	+	@Override
1363	+	public synchronized void forEach(Consumer<? super E> action) {
1364	+	Objects.requireNonNull(action);
1365	+	final int expectedModCount = modCount;
1366	+	final Object[] es = elementData;
1367	+	final int size = elementCount;
1368	+	for (int i = 0; modCount == expectedModCount && i < size; i++)
1369	+	action.accept(elementAt(es, i));
1370	+	if (modCount != expectedModCount)
1371	+	throw new ConcurrentModificationException();
1372	+	// checkInvariants();
1373	+	}
1374	+
1375	+	/**
1376	+	* @throws NullPointerException {@inheritDoc}
1377	+	*/
1378	+	@Override
1379	+	public synchronized void replaceAll(UnaryOperator<E> operator) {
1380	+	Objects.requireNonNull(operator);
1381	+	final int expectedModCount = modCount;
1382	+	final Object[] es = elementData;
1383	+	final int size = elementCount;
1384	+	for (int i = 0; modCount == expectedModCount && i < size; i++)
1385	+	es[i] = operator.apply(elementAt(es, i));
1386	+	if (modCount != expectedModCount)
1387	+	throw new ConcurrentModificationException();
1388	+	modCount++;
1389	+	// checkInvariants();
1390	+	}
1391	+
1392	+	@SuppressWarnings("unchecked")
1393	+	@Override
1394	+	public synchronized void sort(Comparator<? super E> c) {
1395	+	final int expectedModCount = modCount;
1396	+	Arrays.sort((E[]) elementData, 0, elementCount, c);
1397	+	if (modCount != expectedModCount)
1398	+	throw new ConcurrentModificationException();
1399	+	modCount++;
1400	+	// checkInvariants();
1401	+	}
1402	+
1403	+	/**
1404	+	* Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
1405	+	* and <em>fail-fast</em> {@link Spliterator} over the elements in this
1406	+	* list.
1407	+	*
1408	+	* <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
1409	+	* {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
1410	+	* Overriding implementations should document the reporting of additional
1411	+	* characteristic values.
1412	+	*
1413	+	* @return a {@code Spliterator} over the elements in this list
1414	+	* @since 1.8
1415	+	*/
1416	+	@Override
1417	+	public Spliterator<E> spliterator() {
1418	+	return new VectorSpliterator(null, 0, -1, 0);
1419	+	}
1420	+
1421	+	/** Similar to ArrayList Spliterator */
1422	+	final class VectorSpliterator implements Spliterator<E> {
1423	+	private Object[] array;
1424	+	private int index; // current index, modified on advance/split
1425	+	private int fence; // -1 until used; then one past last index
1426	+	private int expectedModCount; // initialized when fence set
1427	+
1428	+	/** Creates new spliterator covering the given range. */
1429	+	VectorSpliterator(Object[] array, int origin, int fence,
1430	+	int expectedModCount) {
1431	+	this.array = array;
1432	+	this.index = origin;
1433	+	this.fence = fence;
1434	+	this.expectedModCount = expectedModCount;
1435	+	}
1436	+
1437	+	private int getFence() { // initialize on first use
1438	+	int hi;
1439	+	if ((hi = fence) < 0) {
1440	+	synchronized (Vector.this) {
1441	+	array = elementData;
1442	+	expectedModCount = modCount;
1443	+	hi = fence = elementCount;
1444	+	}
1445	+	}
1446	+	return hi;
1447	+	}
1448	+
1449	+	public Spliterator<E> trySplit() {
1450	+	int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1451	+	return (lo >= mid) ? null :
1452	+	new VectorSpliterator(array, lo, index = mid, expectedModCount);
1453	+	}
1454	+
1455	+	@SuppressWarnings("unchecked")
1456	+	public boolean tryAdvance(Consumer<? super E> action) {
1457	+	Objects.requireNonNull(action);
1458	+	int i;
1459	+	if (getFence() > (i = index)) {
1460	+	index = i + 1;
1461	+	action.accept((E)array[i]);
1462	+	if (modCount != expectedModCount)
1463	+	throw new ConcurrentModificationException();
1464	+	return true;
1465	+	}
1466	+	return false;
1467	+	}
1468	+
1469	+	@SuppressWarnings("unchecked")
1470	+	public void forEachRemaining(Consumer<? super E> action) {
1471	+	Objects.requireNonNull(action);
1472	+	final int hi = getFence();
1473	+	final Object[] a = array;
1474	+	int i;
1475	+	for (i = index, index = hi; i < hi; i++)
1476	+	action.accept((E) a[i]);
1477	+	if (modCount != expectedModCount)
1478	+	throw new ConcurrentModificationException();
1479	+	}
1480	+
1481	+	public long estimateSize() {
1482	+	return getFence() - index;
1483	+	}
1484	+
1485	+	public int characteristics() {
1486	+	return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
1487	+	}
1488	+	}
1489	+
1490	+	void checkInvariants() {
1491	+	// assert elementCount >= 0;
1492	+	// assert elementCount == elementData.length || elementData[elementCount] == null;
1493	+	}
1494		}

Diff Legend

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