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.28 by jsr166, Sat Oct 16 16:44:39 2010 UTC vs.
Revision 1.54 by jsr166, Thu May 2 14:31:30 2019 UTC

#	Line 1 | Line 1
1		/*
2	<	* Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
2	>	* Copyright (c) 1994, 2018, 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 25 | Line 25
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		/**
36		* The {@code Vector} class implements a growable array of
37		* objects. Like an array, it contains components that can be
#	Line 41 | Line 48 | package java.util;
48		* capacity of a vector before inserting a large number of
49		* components; this reduces the amount of incremental reallocation.
50		*
51	<	* <p><a name="fail-fast"/>
51	>	* <p id="fail-fast">
52		* The iterators returned by this class's {@link #iterator() iterator} and
53		* {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
54		* if the vector is structurally modified at any time after the iterator is
#	Line 52 | Line 59 | package java.util;
59		* concurrent modification, the iterator fails quickly and cleanly, rather
60		* than risking arbitrary, non-deterministic behavior at an undetermined
61		* time in the future.  The {@link Enumeration Enumerations} returned by
62	<	* the {@link #elements() elements} method are <em>not</em> fail-fast.
62	>	* the {@link #elements() elements} method are <em>not</em> fail-fast; if the
63	>	* Vector is structurally modified at any time after the enumeration is
64	>	* created then the results of enumerating are undefined.
65		*
66		* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
67		* as it is, generally speaking, impossible to make any hard guarantees in the
#	Line 64 | Line 73 | package java.util;
73		*
74		* <p>As of the Java 2 platform v1.2, this class was retrofitted to
75		* implement the {@link List} interface, making it a member of the
76	<	* <a href="{@docRoot}/../technotes/guides/collections/index.html">
76	>	* <a href="{@docRoot}/java.base/java/util/package-summary.html#CollectionsFramework">
77		* Java Collections Framework</a>.  Unlike the new collection
78		* implementations, {@code Vector} is synchronized.  If a thread-safe
79		* implementation is not needed, it is recommended to use {@link
80		* ArrayList} in place of {@code Vector}.
81		*
82	+	* @param <E> Type of component elements
83	+	*
84		* @author  Lee Boynton
85		* @author  Jonathan Payne
86		* @see Collection
87		* @see LinkedList
88	<	* @since   JDK1.0
88	>	* @since   1.0
89		*/
90		public class Vector<E>
91		extends AbstractList<E>
#	Line 166 | Line 177 | public class Vector<E>
177		public Vector(Collection<? extends E> c) {
178		elementData = c.toArray();
179		elementCount = elementData.length;
180	<	// c.toArray might (incorrectly) not return Object[] (see 6260652)
180	>	// defend against c.toArray (incorrectly) not returning Object[]
181	>	// (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
182		if (elementData.getClass() != Object[].class)
183		elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
184		}
#	Line 222 | Line 234 | public class Vector<E>
234		* @param minCapacity the desired minimum capacity
235		*/
236		public synchronized void ensureCapacity(int minCapacity) {
237	<	modCount++;
238	<	ensureCapacityHelper(minCapacity);
237	>	if (minCapacity > 0) {
238	>	modCount++;
239	>	if (minCapacity > elementData.length)
240	>	grow(minCapacity);
241	>	}
242	>	}
243	>
244	>	/**
245	>	* The maximum size of array to allocate (unless necessary).
246	>	* Some VMs reserve some header words in an array.
247	>	* Attempts to allocate larger arrays may result in
248	>	* OutOfMemoryError: Requested array size exceeds VM limit
249	>	*/
250	>	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
251	>
252	>	/**
253	>	* Increases the capacity to ensure that it can hold at least the
254	>	* number of elements specified by the minimum capacity argument.
255	>	*
256	>	* @param minCapacity the desired minimum capacity
257	>	* @throws OutOfMemoryError if minCapacity is less than zero
258	>	*/
259	>	private Object[] grow(int minCapacity) {
260	>	return elementData = Arrays.copyOf(elementData,
261	>	newCapacity(minCapacity));
262	>	}
263	>
264	>	private Object[] grow() {
265	>	return grow(elementCount + 1);
266		}
267
268		/**
269	<	* This implements the unsynchronized semantics of ensureCapacity.
270	<	* Synchronized methods in this class can internally call this
271	<	* method for ensuring capacity without incurring the cost of an
233	<	* extra synchronization.
269	>	* Returns a capacity at least as large as the given minimum capacity.
270	>	* Will not return a capacity greater than MAX_ARRAY_SIZE unless
271	>	* the given minimum capacity is greater than MAX_ARRAY_SIZE.
272		*
273	<	* @see #ensureCapacity(int)
273	>	* @param minCapacity the desired minimum capacity
274	>	* @throws OutOfMemoryError if minCapacity is less than zero
275		*/
276	<	private void ensureCapacityHelper(int minCapacity) {
276	>	private int newCapacity(int minCapacity) {
277	>	// overflow-conscious code
278		int oldCapacity = elementData.length;
279	<	if (minCapacity > oldCapacity) {
280	<	Object[] oldData = elementData;
281	<	int newCapacity = (capacityIncrement > 0) ?
282	<	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
283	<	if (newCapacity < minCapacity) {
284	<	newCapacity = minCapacity;
285	<	}
286	<	elementData = Arrays.copyOf(elementData, newCapacity);
287	<	}
279	>	int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
280	>	capacityIncrement : oldCapacity);
281	>	if (newCapacity - minCapacity <= 0) {
282	>	if (minCapacity < 0) // overflow
283	>	throw new OutOfMemoryError();
284	>	return minCapacity;
285	>	}
286	>	return (newCapacity - MAX_ARRAY_SIZE <= 0)
287	>	? newCapacity
288	>	: hugeCapacity(minCapacity);
289	>	}
290	>
291	>	private static int hugeCapacity(int minCapacity) {
292	>	if (minCapacity < 0) // overflow
293	>	throw new OutOfMemoryError();
294	>	return (minCapacity > MAX_ARRAY_SIZE) ?
295	>	Integer.MAX_VALUE :
296	>	MAX_ARRAY_SIZE;
297		}
298
299		/**
#	Line 258 | Line 307 | public class Vector<E>
307		*/
308		public synchronized void setSize(int newSize) {
309		modCount++;
310	<	if (newSize > elementCount) {
311	<	ensureCapacityHelper(newSize);
312	<	} else {
313	<	for (int i = newSize ; i < elementCount ; i++) {
314	<	elementData[i] = null;
266	<	}
267	<	}
310	>	if (newSize > elementData.length)
311	>	grow(newSize);
312	>	final Object[] es = elementData;
313	>	for (int to = elementCount, i = newSize; i < to; i++)
314	>	es[i] = null;
315		elementCount = newSize;
316		}
317
#	Line 303 | Line 350 | public class Vector<E>
350		* Returns an enumeration of the components of this vector. The
351		* returned {@code Enumeration} object will generate all items in
352		* this vector. The first item generated is the item at index {@code 0},
353	<	* then the item at index {@code 1}, and so on.
353	>	* then the item at index {@code 1}, and so on. If the vector is
354	>	* structurally modified while enumerating over the elements then the
355	>	* results of enumerating are undefined.
356		*
357		* @return  an enumeration of the components of this vector
358		* @see     Iterator
#	Line 331 | Line 380 | public class Vector<E>
380		* Returns {@code true} if this vector contains the specified element.
381		* More formally, returns {@code true} if and only if this vector
382		* contains at least one element {@code e} such that
383	<	* <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
383	>	* {@code Objects.equals(o, e)}.
384		*
385		* @param o element whose presence in this vector is to be tested
386		* @return {@code true} if this vector contains the specified element
#	Line 344 | Line 393 | public class Vector<E>
393		* Returns the index of the first occurrence of the specified element
394		* in this vector, or -1 if this vector does not contain the element.
395		* More formally, returns the lowest index {@code i} such that
396	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
396	>	* {@code Objects.equals(o, get(i))},
397		* or -1 if there is no such index.
398		*
399		* @param o element to search for
#	Line 360 | Line 409 | public class Vector<E>
409		* this vector, searching forwards from {@code index}, or returns -1 if
410		* the element is not found.
411		* More formally, returns the lowest index {@code i} such that
412	<	* <tt>(i&nbsp;&gt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
412	>	* {@code (i >= index && Objects.equals(o, get(i)))},
413		* or -1 if there is no such index.
414		*
415		* @param o element to search for
#	Line 388 | Line 437 | public class Vector<E>
437		* Returns the index of the last occurrence of the specified element
438		* in this vector, or -1 if this vector does not contain the element.
439		* More formally, returns the highest index {@code i} such that
440	<	* <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
440	>	* {@code Objects.equals(o, get(i))},
441		* or -1 if there is no such index.
442		*
443		* @param o element to search for
#	Line 404 | Line 453 | public class Vector<E>
453		* this vector, searching backwards from {@code index}, or returns -1 if
454		* the element is not found.
455		* More formally, returns the highest index {@code i} such that
456	<	* <tt>(i&nbsp;&lt;=&nbsp;index&nbsp;&amp;&amp;&nbsp;(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i))))</tt>,
456	>	* {@code (i <= index && Objects.equals(o, get(i)))},
457		* or -1 if there is no such index.
458		*
459		* @param o element to search for
#	Line 468 | Line 517 | public class Vector<E>
517		* Returns the last component of the vector.
518		*
519		* @return  the last component of the vector, i.e., the component at index
520	<	*          <code>size()&nbsp;-&nbsp;1</code>.
520	>	*          {@code size() - 1}
521		* @throws NoSuchElementException if this vector is empty
522		*/
523		public synchronized E lastElement() {
#	Line 526 | Line 575 | public class Vector<E>
575		*         ({@code index < 0 || index >= size()})
576		*/
577		public synchronized void removeElementAt(int index) {
529	–	modCount++;
578		if (index >= elementCount) {
579		throw new ArrayIndexOutOfBoundsException(index + " >= " +
580		elementCount);
#	Line 538 | Line 586 | public class Vector<E>
586		if (j > 0) {
587		System.arraycopy(elementData, index + 1, elementData, index, j);
588		}
589	+	modCount++;
590		elementCount--;
591		elementData[elementCount] = null; /* to let gc do its work */
592	+	// checkInvariants();
593		}
594
595		/**
#	Line 566 | Line 616 | public class Vector<E>
616		*         ({@code index < 0 || index > size()})
617		*/
618		public synchronized void insertElementAt(E obj, int index) {
569	–	modCount++;
619		if (index > elementCount) {
620		throw new ArrayIndexOutOfBoundsException(index
621		+ " > " + elementCount);
622		}
623	<	ensureCapacityHelper(elementCount + 1);
624	<	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
623	>	modCount++;
624	>	final int s = elementCount;
625	>	Object[] elementData = this.elementData;
626	>	if (s == elementData.length)
627	>	elementData = grow();
628	>	System.arraycopy(elementData, index,
629	>	elementData, index + 1,
630	>	s - index);
631		elementData[index] = obj;
632	<	elementCount++;
632	>	elementCount = s + 1;
633		}
634
635		/**
#	Line 590 | Line 645 | public class Vector<E>
645		*/
646		public synchronized void addElement(E obj) {
647		modCount++;
648	<	ensureCapacityHelper(elementCount + 1);
594	<	elementData[elementCount++] = obj;
648	>	add(obj, elementData, elementCount);
649		}
650
651		/**
#	Line 626 | Line 680 | public class Vector<E>
680		* method (which is part of the {@link List} interface).
681		*/
682		public synchronized void removeAllElements() {
683	+	final Object[] es = elementData;
684	+	for (int to = elementCount, i = elementCount = 0; i < to; i++)
685	+	es[i] = null;
686		modCount++;
630	–	// Let gc do its work
631	–	for (int i = 0; i < elementCount; i++)
632	–	elementData[i] = null;
633	–
634	–	elementCount = 0;
687		}
688
689		/**
#	Line 644 | Line 696 | public class Vector<E>
696		public synchronized Object clone() {
697		try {
698		@SuppressWarnings("unchecked")
699	<	Vector<E> v = (Vector<E>) super.clone();
699	>	Vector<E> v = (Vector<E>) super.clone();
700		v.elementData = Arrays.copyOf(elementData, elementCount);
701		v.modCount = 0;
702		return v;
703		} catch (CloneNotSupportedException e) {
704		// this shouldn't happen, since we are Cloneable
705	<	throw new InternalError();
705	>	throw new InternalError(e);
706		}
707		}
708
#	Line 678 | Line 730 | public class Vector<E>
730		* of the Vector <em>only</em> if the caller knows that the Vector
731		* does not contain any null elements.)
732		*
733	+	* @param <T> type of array elements. The same type as {@code <E>} or a
734	+	* supertype of {@code <E>}.
735		* @param a the array into which the elements of the Vector are to
736		*          be stored, if it is big enough; otherwise, a new array of the
737		*          same runtime type is allocated for this purpose.
738		* @return an array containing the elements of the Vector
739	<	* @throws ArrayStoreException if the runtime type of a is not a supertype
740	<	* of the runtime type of every element in this Vector
739	>	* @throws ArrayStoreException if the runtime type of a, {@code <T>}, is not
740	>	* a supertype of the runtime type, {@code <E>}, of every element in this
741	>	* Vector
742		* @throws NullPointerException if the given array is null
743		* @since 1.2
744		*/
#	Line 707 | Line 762 | public class Vector<E>
762		return (E) elementData[index];
763		}
764
765	+	@SuppressWarnings("unchecked")
766	+	static <E> E elementAt(Object[] es, int index) {
767	+	return (E) es[index];
768	+	}
769	+
770		/**
771		* Returns the element at the specified position in this Vector.
772		*
#	Line 744 | Line 804 | public class Vector<E>
804		}
805
806		/**
807	+	* This helper method split out from add(E) to keep method
808	+	* bytecode size under 35 (the -XX:MaxInlineSize default value),
809	+	* which helps when add(E) is called in a C1-compiled loop.
810	+	*/
811	+	private void add(E e, Object[] elementData, int s) {
812	+	if (s == elementData.length)
813	+	elementData = grow();
814	+	elementData[s] = e;
815	+	elementCount = s + 1;
816	+	// checkInvariants();
817	+	}
818	+
819	+	/**
820		* Appends the specified element to the end of this Vector.
821		*
822		* @param e element to be appended to this Vector
#	Line 752 | Line 825 | public class Vector<E>
825		*/
826		public synchronized boolean add(E e) {
827		modCount++;
828	<	ensureCapacityHelper(elementCount + 1);
756	<	elementData[elementCount++] = e;
828	>	add(e, elementData, elementCount);
829		return true;
830		}
831
#	Line 761 | Line 833 | public class Vector<E>
833		* Removes the first occurrence of the specified element in this Vector
834		* If the Vector does not contain the element, it is unchanged.  More
835		* formally, removes the element with the lowest index i such that
836	<	* {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
836	>	* {@code Objects.equals(o, get(i))} (if such
837		* an element exists).
838		*
839		* @param o element to be removed from this Vector, if present
#	Line 792 | Line 864 | public class Vector<E>
864		* Shifts any subsequent elements to the left (subtracts one from their
865		* indices).  Returns the element that was removed from the Vector.
866		*
795	–	* @throws ArrayIndexOutOfBoundsException if the index is out of range
796	–	*         ({@code index < 0 || index >= size()})
867		* @param index the index of the element to be removed
868		* @return element that was removed
869	+	* @throws ArrayIndexOutOfBoundsException if the index is out of range
870	+	*         ({@code index < 0 || index >= size()})
871		* @since 1.2
872		*/
873		public synchronized E remove(int index) {
#	Line 810 | Line 882 | public class Vector<E>
882		numMoved);
883		elementData[--elementCount] = null; // Let gc do its work
884
885	+	// checkInvariants();
886		return oldValue;
887		}
888
#	Line 852 | Line 925 | public class Vector<E>
925		* @throws NullPointerException if the specified collection is null
926		* @since 1.2
927		*/
928	<	public synchronized boolean addAll(Collection<? extends E> c) {
856	<	modCount++;
928	>	public boolean addAll(Collection<? extends E> c) {
929		Object[] a = c.toArray();
930	+	modCount++;
931		int numNew = a.length;
932	<	ensureCapacityHelper(elementCount + numNew);
933	<	System.arraycopy(a, 0, elementData, elementCount, numNew);
934	<	elementCount += numNew;
935	<	return numNew != 0;
932	>	if (numNew == 0)
933	>	return false;
934	>	synchronized (this) {
935	>	Object[] elementData = this.elementData;
936	>	final int s = elementCount;
937	>	if (numNew > elementData.length - s)
938	>	elementData = grow(s + numNew);
939	>	System.arraycopy(a, 0, elementData, s, numNew);
940	>	elementCount = s + numNew;
941	>	// checkInvariants();
942	>	return true;
943	>	}
944		}
945
946		/**
#	Line 870 | Line 951 | public class Vector<E>
951		* @return true if this Vector changed as a result of the call
952		* @throws ClassCastException if the types of one or more elements
953		*         in this vector are incompatible with the specified
954	<	*         collection (optional)
954	>	*         collection
955	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
956		* @throws NullPointerException if this vector contains one or more null
957		*         elements and the specified collection does not support null
958	<	*         elements (optional), or if the specified collection is null
958	>	*         elements
959	>	* (<a href="Collection.html#optional-restrictions">optional</a>),
960	>	*         or if the specified collection is null
961		* @since 1.2
962		*/
963	<	public synchronized boolean removeAll(Collection<?> c) {
964	<	return super.removeAll(c);
963	>	public boolean removeAll(Collection<?> c) {
964	>	Objects.requireNonNull(c);
965	>	return bulkRemove(e -> c.contains(e));
966		}
967
968		/**
#	Line 890 | Line 975 | public class Vector<E>
975		* @return true if this Vector changed as a result of the call
976		* @throws ClassCastException if the types of one or more elements
977		*         in this vector are incompatible with the specified
978	<	*         collection (optional)
978	>	*         collection
979	>	* (<a href="Collection.html#optional-restrictions">optional</a>)
980		* @throws NullPointerException if this vector contains one or more null
981		*         elements and the specified collection does not support null
982	<	*         elements (optional), or if the specified collection is null
982	>	*         elements
983	>	*         (<a href="Collection.html#optional-restrictions">optional</a>),
984	>	*         or if the specified collection is null
985		* @since 1.2
986		*/
987	<	public synchronized boolean retainAll(Collection<?> c) {
988	<	return super.retainAll(c);
987	>	public boolean retainAll(Collection<?> c) {
988	>	Objects.requireNonNull(c);
989	>	return bulkRemove(e -> !c.contains(e));
990	>	}
991	>
992	>	/**
993	>	* @throws NullPointerException {@inheritDoc}
994	>	*/
995	>	@Override
996	>	public boolean removeIf(Predicate<? super E> filter) {
997	>	Objects.requireNonNull(filter);
998	>	return bulkRemove(filter);
999	>	}
1000	>
1001	>	// A tiny bit set implementation
1002	>
1003	>	private static long[] nBits(int n) {
1004	>	return new long[((n - 1) >> 6) + 1];
1005	>	}
1006	>	private static void setBit(long[] bits, int i) {
1007	>	bits[i >> 6] |= 1L << i;
1008	>	}
1009	>	private static boolean isClear(long[] bits, int i) {
1010	>	return (bits[i >> 6] & (1L << i)) == 0;
1011	>	}
1012	>
1013	>	private synchronized boolean bulkRemove(Predicate<? super E> filter) {
1014	>	int expectedModCount = modCount;
1015	>	final Object[] es = elementData;
1016	>	final int end = elementCount;
1017	>	int i;
1018	>	// Optimize for initial run of survivors
1019	>	for (i = 0; i < end && !filter.test(elementAt(es, i)); i++)
1020	>	;
1021	>	// Tolerate predicates that reentrantly access the collection for
1022	>	// read (but writers still get CME), so traverse once to find
1023	>	// elements to delete, a second pass to physically expunge.
1024	>	if (i < end) {
1025	>	final int beg = i;
1026	>	final long[] deathRow = nBits(end - beg);
1027	>	deathRow[0] = 1L;   // set bit 0
1028	>	for (i = beg + 1; i < end; i++)
1029	>	if (filter.test(elementAt(es, i)))
1030	>	setBit(deathRow, i - beg);
1031	>	if (modCount != expectedModCount)
1032	>	throw new ConcurrentModificationException();
1033	>	modCount++;
1034	>	int w = beg;
1035	>	for (i = beg; i < end; i++)
1036	>	if (isClear(deathRow, i - beg))
1037	>	es[w++] = es[i];
1038	>	for (i = elementCount = w; i < end; i++)
1039	>	es[i] = null;
1040	>	// checkInvariants();
1041	>	return true;
1042	>	} else {
1043	>	if (modCount != expectedModCount)
1044	>	throw new ConcurrentModificationException();
1045	>	// checkInvariants();
1046	>	return false;
1047	>	}
1048		}
1049
1050		/**
#	Line 918 | Line 1065 | public class Vector<E>
1065		* @since 1.2
1066		*/
1067		public synchronized boolean addAll(int index, Collection<? extends E> c) {
921	–	modCount++;
1068		if (index < 0 || index > elementCount)
1069		throw new ArrayIndexOutOfBoundsException(index);
1070
1071		Object[] a = c.toArray();
1072	+	modCount++;
1073		int numNew = a.length;
1074	<	ensureCapacityHelper(elementCount + numNew);
1074	>	if (numNew == 0)
1075	>	return false;
1076	>	Object[] elementData = this.elementData;
1077	>	final int s = elementCount;
1078	>	if (numNew > elementData.length - s)
1079	>	elementData = grow(s + numNew);
1080
1081	<	int numMoved = elementCount - index;
1081	>	int numMoved = s - index;
1082		if (numMoved > 0)
1083	<	System.arraycopy(elementData, index, elementData, index + numNew,
1083	>	System.arraycopy(elementData, index,
1084	>	elementData, index + numNew,
1085		numMoved);
933	–
1086		System.arraycopy(a, 0, elementData, index, numNew);
1087	<	elementCount += numNew;
1088	<	return numNew != 0;
1087	>	elementCount = s + numNew;
1088	>	// checkInvariants();
1089	>	return true;
1090		}
1091
1092		/**
#	Line 941 | Line 1094 | public class Vector<E>
1094		* true if and only if the specified Object is also a List, both Lists
1095		* have the same size, and all corresponding pairs of elements in the two
1096		* Lists are <em>equal</em>.  (Two elements {@code e1} and
1097	<	* {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
1098	<	* e1.equals(e2))}.)  In other words, two Lists are defined to be
1097	>	* {@code e2} are <em>equal</em> if {@code Objects.equals(e1, e2)}.)
1098	>	* In other words, two Lists are defined to be
1099		* equal if they contain the same elements in the same order.
1100		*
1101		* @param o the Object to be compared for equality with this Vector
#	Line 1015 | Line 1168 | public class Vector<E>
1168		*/
1169		protected synchronized void removeRange(int fromIndex, int toIndex) {
1170		modCount++;
1171	<	int numMoved = elementCount - toIndex;
1172	<	System.arraycopy(elementData, toIndex, elementData, fromIndex,
1173	<	numMoved);
1171	>	shiftTailOverGap(elementData, fromIndex, toIndex);
1172	>	// checkInvariants();
1173	>	}
1174
1175	<	// Let gc do its work
1176	<	int newElementCount = elementCount - (toIndex-fromIndex);
1177	<	while (elementCount != newElementCount)
1178	<	elementData[--elementCount] = null;
1175	>	/** Erases the gap from lo to hi, by sliding down following elements. */
1176	>	private void shiftTailOverGap(Object[] es, int lo, int hi) {
1177	>	System.arraycopy(es, hi, es, lo, elementCount - hi);
1178	>	for (int to = elementCount, i = (elementCount -= hi - lo); i < to; i++)
1179	>	es[i] = null;
1180		}
1181
1182		/**
1183	<	* Save the state of the {@code Vector} instance to a stream (that
1184	<	* is, serialize it).  This method is present merely for synchronization.
1185	<	* It just calls the default writeObject method.
1183	>	* Loads a {@code Vector} instance from a stream
1184	>	* (that is, deserializes it).
1185	>	* This method performs checks to ensure the consistency
1186	>	* of the fields.
1187	>	*
1188	>	* @param in the stream
1189	>	* @throws java.io.IOException if an I/O error occurs
1190	>	* @throws ClassNotFoundException if the stream contains data
1191	>	*         of a non-existing class
1192		*/
1193	<	private synchronized void writeObject(java.io.ObjectOutputStream s)
1194	<	throws java.io.IOException
1195	<	{
1196	<	s.defaultWriteObject();
1193	>	private void readObject(ObjectInputStream in)
1194	>	throws IOException, ClassNotFoundException {
1195	>	ObjectInputStream.GetField gfields = in.readFields();
1196	>	int count = gfields.get("elementCount", 0);
1197	>	Object[] data = (Object[])gfields.get("elementData", null);
1198	>	if (count < 0 || data == null || count > data.length) {
1199	>	throw new StreamCorruptedException("Inconsistent vector internals");
1200	>	}
1201	>	elementCount = count;
1202	>	elementData = data.clone();
1203	>	}
1204	>
1205	>	/**
1206	>	* Saves the state of the {@code Vector} instance to a stream
1207	>	* (that is, serializes it).
1208	>	* This method performs synchronization to ensure the consistency
1209	>	* of the serialized data.
1210	>	*
1211	>	* @param s the stream
1212	>	* @throws java.io.IOException if an I/O error occurs
1213	>	*/
1214	>	private void writeObject(java.io.ObjectOutputStream s)
1215	>	throws java.io.IOException {
1216	>	final java.io.ObjectOutputStream.PutField fields = s.putFields();
1217	>	final Object[] data;
1218	>	synchronized (this) {
1219	>	fields.put("capacityIncrement", capacityIncrement);
1220	>	fields.put("elementCount", elementCount);
1221	>	data = elementData.clone();
1222	>	}
1223	>	fields.put("elementData", data);
1224	>	s.writeFields();
1225		}
1226
1227		/**
#	Line 1114 | Line 1302 | public class Vector<E>
1302		lastRet = -1;
1303		}
1304
1305	+	@Override
1306	+	public void forEachRemaining(Consumer<? super E> action) {
1307	+	Objects.requireNonNull(action);
1308	+	synchronized (Vector.this) {
1309	+	final int size = elementCount;
1310	+	int i = cursor;
1311	+	if (i >= size) {
1312	+	return;
1313	+	}
1314	+	final Object[] es = elementData;
1315	+	if (i >= es.length)
1316	+	throw new ConcurrentModificationException();
1317	+	while (i < size && modCount == expectedModCount)
1318	+	action.accept(elementAt(es, i++));
1319	+	// update once at end of iteration to reduce heap write traffic
1320	+	cursor = i;
1321	+	lastRet = i - 1;
1322	+	checkForComodification();
1323	+	}
1324	+	}
1325	+
1326		final void checkForComodification() {
1327		if (modCount != expectedModCount)
1328		throw new ConcurrentModificationException();
#	Line 1172 | Line 1381 | public class Vector<E>
1381		lastRet = -1;
1382		}
1383		}
1384	+
1385	+	/**
1386	+	* @throws NullPointerException {@inheritDoc}
1387	+	*/
1388	+	@Override
1389	+	public synchronized void forEach(Consumer<? super E> action) {
1390	+	Objects.requireNonNull(action);
1391	+	final int expectedModCount = modCount;
1392	+	final Object[] es = elementData;
1393	+	final int size = elementCount;
1394	+	for (int i = 0; modCount == expectedModCount && i < size; i++)
1395	+	action.accept(elementAt(es, i));
1396	+	if (modCount != expectedModCount)
1397	+	throw new ConcurrentModificationException();
1398	+	// checkInvariants();
1399	+	}
1400	+
1401	+	/**
1402	+	* @throws NullPointerException {@inheritDoc}
1403	+	*/
1404	+	@Override
1405	+	public synchronized void replaceAll(UnaryOperator<E> operator) {
1406	+	Objects.requireNonNull(operator);
1407	+	final int expectedModCount = modCount;
1408	+	final Object[] es = elementData;
1409	+	final int size = elementCount;
1410	+	for (int i = 0; modCount == expectedModCount && i < size; i++)
1411	+	es[i] = operator.apply(elementAt(es, i));
1412	+	if (modCount != expectedModCount)
1413	+	throw new ConcurrentModificationException();
1414	+	// TODO(8203662): remove increment of modCount from ...
1415	+	modCount++;
1416	+	// checkInvariants();
1417	+	}
1418	+
1419	+	@SuppressWarnings("unchecked")
1420	+	@Override
1421	+	public synchronized void sort(Comparator<? super E> c) {
1422	+	final int expectedModCount = modCount;
1423	+	Arrays.sort((E[]) elementData, 0, elementCount, c);
1424	+	if (modCount != expectedModCount)
1425	+	throw new ConcurrentModificationException();
1426	+	modCount++;
1427	+	// checkInvariants();
1428	+	}
1429	+
1430	+	/**
1431	+	* Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
1432	+	* and <em>fail-fast</em> {@link Spliterator} over the elements in this
1433	+	* list.
1434	+	*
1435	+	* <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
1436	+	* {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
1437	+	* Overriding implementations should document the reporting of additional
1438	+	* characteristic values.
1439	+	*
1440	+	* @return a {@code Spliterator} over the elements in this list
1441	+	* @since 1.8
1442	+	*/
1443	+	@Override
1444	+	public Spliterator<E> spliterator() {
1445	+	return new VectorSpliterator(null, 0, -1, 0);
1446	+	}
1447	+
1448	+	/** Similar to ArrayList Spliterator */
1449	+	final class VectorSpliterator implements Spliterator<E> {
1450	+	private Object[] array;
1451	+	private int index; // current index, modified on advance/split
1452	+	private int fence; // -1 until used; then one past last index
1453	+	private int expectedModCount; // initialized when fence set
1454	+
1455	+	/** Creates new spliterator covering the given range. */
1456	+	VectorSpliterator(Object[] array, int origin, int fence,
1457	+	int expectedModCount) {
1458	+	this.array = array;
1459	+	this.index = origin;
1460	+	this.fence = fence;
1461	+	this.expectedModCount = expectedModCount;
1462	+	}
1463	+
1464	+	private int getFence() { // initialize on first use
1465	+	int hi;
1466	+	if ((hi = fence) < 0) {
1467	+	synchronized (Vector.this) {
1468	+	array = elementData;
1469	+	expectedModCount = modCount;
1470	+	hi = fence = elementCount;
1471	+	}
1472	+	}
1473	+	return hi;
1474	+	}
1475	+
1476	+	public Spliterator<E> trySplit() {
1477	+	int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
1478	+	return (lo >= mid) ? null :
1479	+	new VectorSpliterator(array, lo, index = mid, expectedModCount);
1480	+	}
1481	+
1482	+	@SuppressWarnings("unchecked")
1483	+	public boolean tryAdvance(Consumer<? super E> action) {
1484	+	Objects.requireNonNull(action);
1485	+	int i;
1486	+	if (getFence() > (i = index)) {
1487	+	index = i + 1;
1488	+	action.accept((E)array[i]);
1489	+	if (modCount != expectedModCount)
1490	+	throw new ConcurrentModificationException();
1491	+	return true;
1492	+	}
1493	+	return false;
1494	+	}
1495	+
1496	+	@SuppressWarnings("unchecked")
1497	+	public void forEachRemaining(Consumer<? super E> action) {
1498	+	Objects.requireNonNull(action);
1499	+	final int hi = getFence();
1500	+	final Object[] a = array;
1501	+	int i;
1502	+	for (i = index, index = hi; i < hi; i++)
1503	+	action.accept((E) a[i]);
1504	+	if (modCount != expectedModCount)
1505	+	throw new ConcurrentModificationException();
1506	+	}
1507	+
1508	+	public long estimateSize() {
1509	+	return getFence() - index;
1510	+	}
1511	+
1512	+	public int characteristics() {
1513	+	return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
1514	+	}
1515	+	}
1516	+
1517	+	void checkInvariants() {
1518	+	// assert elementCount >= 0;
1519	+	// assert elementCount == elementData.length || elementData[elementCount] == null;
1520	+	}
1521		}

Diff Legend

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