ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/main/java/util/ArrayDeque.java

Comparing jsr166/src/main/java/util/ArrayDeque.java (file contents):
Revision 1.50 by jsr166, Wed Feb 20 12:32:01 2013 UTC vs.
Revision 1.61 by jsr166, Wed Dec 31 07:54:13 2014 UTC

#	Line 4 | Line 4
4		*/
5
6		package java.util;
7	+
8		import java.io.Serializable;
9		import java.util.function.Consumer;
10		import java.util.stream.Stream;
10	–	import java.util.stream.Streams;
11
12		/**
13		* Resizable-array implementation of the {@link Deque} interface.  Array
#	Line 19 | Line 19 | import java.util.stream.Streams;
19		* when used as a queue.
20		*
21		* <p>Most {@code ArrayDeque} operations run in amortized constant time.
22	<	* Exceptions include {@link #remove(Object) remove}, {@link
23	<	* #removeFirstOccurrence removeFirstOccurrence}, {@link #removeLastOccurrence
24	<	* removeLastOccurrence}, {@link #contains contains}, {@link #iterator
25	<	* iterator.remove()}, and the bulk operations, all of which run in linear
26	<	* time.
22	>	* Exceptions include
23	>	* {@link #remove(Object) remove},
24	>	* {@link #removeFirstOccurrence removeFirstOccurrence},
25	>	* {@link #removeLastOccurrence removeLastOccurrence},
26	>	* {@link #contains contains},
27	>	* {@link #iterator iterator.remove()},
28	>	* and the bulk operations, all of which run in linear time.
29		*
30	<	* <p>The iterators returned by this class's {@code iterator} method are
31	<	* <i>fail-fast</i>: If the deque is modified at any time after the iterator
32	<	* is created, in any way except through the iterator's own {@code remove}
33	<	* method, the iterator will generally throw a {@link
30	>	* <p>The iterators returned by this class's {@link #iterator() iterator}
31	>	* method are <em>fail-fast</em>: If the deque is modified at any time after
32	>	* the iterator is created, in any way except through the iterator's own
33	>	* {@code remove} method, the iterator will generally throw a {@link
34		* ConcurrentModificationException}.  Thus, in the face of concurrent
35		* modification, the iterator fails quickly and cleanly, rather than risking
36		* arbitrary, non-deterministic behavior at an undetermined time in the
#	Line 52 | Line 54 | import java.util.stream.Streams;
54		*
55		* @author  Josh Bloch and Doug Lea
56		* @since   1.6
57	<	* @param <E> the type of elements held in this collection
57	>	* @param <E> the type of elements held in this deque
58		*/
59		public class ArrayDeque<E> extends AbstractCollection<E>
60		implements Deque<E>, Cloneable, Serializable
#	Line 314 | Line 316 | public class ArrayDeque<E> extends Abstr
316		* @return {@code true} if the deque contained the specified element
317		*/
318		public boolean removeFirstOccurrence(Object o) {
319	<	if (o == null)
320	<	return false;
321	<	int mask = elements.length - 1;
322	<	int i = head;
323	<	Object x;
324	<	while ( (x = elements[i]) != null) {
325	<	if (o.equals(x)) {
326	<	delete(i);
325	<	return true;
319	>	if (o != null) {
320	>	int mask = elements.length - 1;
321	>	int i = head;
322	>	for (Object x; (x = elements[i]) != null; i = (i + 1) & mask) {
323	>	if (o.equals(x)) {
324	>	delete(i);
325	>	return true;
326	>	}
327		}
327	–	i = (i + 1) & mask;
328		}
329		return false;
330		}
#	Line 342 | Line 342 | public class ArrayDeque<E> extends Abstr
342		* @return {@code true} if the deque contained the specified element
343		*/
344		public boolean removeLastOccurrence(Object o) {
345	<	if (o == null)
346	<	return false;
347	<	int mask = elements.length - 1;
348	<	int i = (tail - 1) & mask;
349	<	Object x;
350	<	while ( (x = elements[i]) != null) {
351	<	if (o.equals(x)) {
352	<	delete(i);
353	<	return true;
345	>	if (o != null) {
346	>	int mask = elements.length - 1;
347	>	int i = (tail - 1) & mask;
348	>	for (Object x; (x = elements[i]) != null; i = (i - 1) & mask) {
349	>	if (o.equals(x)) {
350	>	delete(i);
351	>	return true;
352	>	}
353		}
355	–	i = (i - 1) & mask;
354		}
355		return false;
356		}
#	Line 611 | Line 609 | public class ArrayDeque<E> extends Abstr
609		}
610		}
611
612	+	/**
613	+	* This class is nearly a mirror-image of DeqIterator, using tail
614	+	* instead of head for initial cursor, and head instead of tail
615	+	* for fence.
616	+	*/
617		private class DescendingIterator implements Iterator<E> {
615	–	/*
616	–	* This class is nearly a mirror-image of DeqIterator, using
617	–	* tail instead of head for initial cursor, and head instead of
618	–	* tail for fence.
619	–	*/
618		private int cursor = tail;
619		private int fence = head;
620		private int lastRet = -1;
#	Line 657 | Line 655 | public class ArrayDeque<E> extends Abstr
655		* @return {@code true} if this deque contains the specified element
656		*/
657		public boolean contains(Object o) {
658	<	if (o == null)
659	<	return false;
660	<	int mask = elements.length - 1;
661	<	int i = head;
662	<	Object x;
663	<	while ( (x = elements[i]) != null) {
664	<	if (o.equals(x))
667	<	return true;
668	<	i = (i + 1) & mask;
658	>	if (o != null) {
659	>	int mask = elements.length - 1;
660	>	int i = head;
661	>	for (Object x; (x = elements[i]) != null; i = (i + 1) & mask) {
662	>	if (o.equals(x))
663	>	return true;
664	>	}
665		}
666		return false;
667		}
#	Line 809 | Line 805 | public class ArrayDeque<E> extends Abstr
805		/**
806		* Saves this deque to a stream (that is, serializes it).
807		*
808	+	* @param s the stream
809	+	* @throws java.io.IOException if an I/O error occurs
810		* @serialData The current size ({@code int}) of the deque,
811		* followed by all of its elements (each an object reference) in
812		* first-to-last order.
#	Line 828 | Line 826 | public class ArrayDeque<E> extends Abstr
826
827		/**
828		* Reconstitutes this deque from a stream (that is, deserializes it).
829	+	* @param s the stream
830	+	* @throws ClassNotFoundException if the class of a serialized object
831	+	*         could not be found
832	+	* @throws java.io.IOException if an I/O error occurs
833		*/
834		private void readObject(java.io.ObjectInputStream s)
835		throws java.io.IOException, ClassNotFoundException {
#	Line 844 | Line 846 | public class ArrayDeque<E> extends Abstr
846		elements[i] = s.readObject();
847		}
848
849	<	Spliterator<E> spliterator() {
849	>	public Spliterator<E> spliterator() {
850		return new DeqSpliterator<E>(this, -1, -1);
851		}
852
851	–	public Stream<E> stream() {
852	–	return Streams.stream(spliterator());
853	–	}
854	–
855	–	public Stream<E> parallelStream() {
856	–	return Streams.parallelStream(spliterator());
857	–	}
858	–
853		static final class DeqSpliterator<E> implements Spliterator<E> {
854		private final ArrayDeque<E> deq;
855		private int fence;  // -1 until first use
#	Line 877 | Line 871 | public class ArrayDeque<E> extends Abstr
871		return t;
872		}
873
874	<	public DeqSpliterator<E> trySplit() {
874	>	public Spliterator<E> trySplit() {
875		int t = getFence(), h = index, n = deq.elements.length;
876		if (h != t && ((h + 1) & (n - 1)) != t) {
877		if (h > t)
#	Line 888 | Line 882 | public class ArrayDeque<E> extends Abstr
882		return null;
883		}
884
885	<	public void forEach(Consumer<? super E> consumer) {
885	>	public void forEachRemaining(Consumer<? super E> consumer) {
886		if (consumer == null)
887		throw new NullPointerException();
888		Object[] a = deq.elements;

Diff Legend

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