Most ArrayDeque operations run in amortized constant time. * Exceptions include {@link #remove(Object) remove}, {@link * #removeFirstOccurrence removeFirstOccurrence}, {@link #removeLastOccurrence - * removeLastOccurrence}, {@link #contains contains }, {@link #iterator + * removeLastOccurrence}, {@link #contains contains}, {@link #iterator * iterator.remove()}, and the bulk operations, all of which run in linear * time. * *
The iterators returned by this class's iterator method are * fail-fast: If the deque is modified at any time after the iterator - * is created, in any way except through the iterator's own remove method, the - * iterator will generally throw a {@link ConcurrentModificationException}. - * Thus, in the face of concurrent modification, the iterator fails quickly - * and cleanly, rather than risking arbitrary, non-deterministic behavior at - * an undetermined time in the future. + * is created, in any way except through the iterator's own remove + * method, the iterator will generally throw a {@link + * ConcurrentModificationException}. Thus, in the face of concurrent + * modification, the iterator fails quickly and cleanly, rather than risking + * arbitrary, non-deterministic behavior at an undetermined time in the + * future. * *
Note that the fail-fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the @@ -39,10 +40,12 @@ import java.io.*; * should be used only to detect bugs. * *
This class and its iterator implement all of the - * optional methods of the {@link Collection} and {@link - * Iterator} interfaces. This class is a member of the Java Collections - * Framework. + * optional methods of the {@link Collection} and {@link + * Iterator} interfaces. + * + *
This class is a member of the
+ *
+ * Java Collections Framework.
*
* @author Josh Bloch and Doug Lea
* @since 1.6
@@ -87,7 +90,7 @@ public class ArrayDeque This method is equivalent to {@link #add}.
+ *
+ * @param e the element to add
+ * @throws NullPointerException if the specified element is null
*/
public void addLast(E e) {
if (e == null)
@@ -214,45 +217,11 @@ public class ArrayDeque This method is equivalent to {@link #offerLast}.
- *
- * @param e the element to insert
- * @return true (as per the spec for {@link Queue#offer})
- * @throws NullPointerException if e is null
- */
- public boolean offer(E e) {
- return offerLast(e);
- }
-
- /**
- * Inserts the specified element at the end of this deque.
- *
* This method is equivalent to {@link #addLast}.
*
- * @param e the element to insert
- * @return true (as per the spec for {@link Collection#add})
- * @throws NullPointerException if e is null
+ * @param e the element to add
+ * @return true (as specified by {@link Collection#add})
+ * @throws NullPointerException if the specified element is null
*/
public boolean add(E e) {
addLast(e);
@@ -435,61 +381,74 @@ public class ArrayDeque This method is equivalent to {@link #pollFirst}.
+ * This method is equivalent to {@link #offerLast}.
*
- * @return the first element of this deque, or null if
- * this deque is empty
+ * @param e the element to add
+ * @return true (as specified by {@link Queue#offer})
+ * @throws NullPointerException if the specified element is null
*/
- public E poll() {
- return pollFirst();
+ public boolean offer(E e) {
+ return offerLast(e);
}
/**
* Retrieves and removes the head of the queue represented by this deque.
- * This method differs from the poll method in that it throws an
+ *
+ * This method differs from {@link #poll poll} only in that it throws an
* exception if this deque is empty.
*
* This method is equivalent to {@link #removeFirst}.
*
* @return the head of the queue represented by this deque
- * @throws NoSuchElementException if this deque is empty
+ * @throws NoSuchElementException {@inheritDoc}
*/
public E remove() {
return removeFirst();
}
/**
- * Retrieves, but does not remove, the head of the queue represented by
- * this deque, returning null if this deque is empty.
+ * Retrieves and removes the head of the queue represented by this deque
+ * (in other words, the first element of this deque), or returns
+ * null if this deque is empty.
*
- * This method is equivalent to {@link #peekFirst}
+ * This method is equivalent to {@link #pollFirst}.
*
* @return the head of the queue represented by this deque, or
- * null if this deque is empty
+ * null if this deque is empty
*/
- public E peek() {
- return peekFirst();
+ public E poll() {
+ return pollFirst();
}
/**
* Retrieves, but does not remove, the head of the queue represented by
- * this deque. This method differs from the peek method only in
+ * this deque. This method differs from {@link #peek peek} only in
* that it throws an exception if this deque is empty.
*
- * This method is equivalent to {@link #getFirst}
+ * This method is equivalent to {@link #getFirst}.
*
* @return the head of the queue represented by this deque
- * @throws NoSuchElementException if this deque is empty
+ * @throws NoSuchElementException {@inheritDoc}
*/
public E element() {
return getFirst();
}
+ /**
+ * Retrieves, but does not remove, the head of the queue represented by
+ * this deque, or returns null if this deque is empty.
+ *
+ * This method is equivalent to {@link #peekFirst}.
+ *
+ * @return the head of the queue represented by this deque, or
+ * null if this deque is empty
+ */
+ public E peek() {
+ return peekFirst();
+ }
+
// *** Stack methods ***
/**
@@ -499,7 +458,7 @@ public class ArrayDeque This method is equivalent to {@link #addFirst}.
*
* @param e the element to push
- * @throws NullPointerException if e is null
+ * @throws NullPointerException if the specified element is null
*/
public void push(E e) {
addFirst(e);
@@ -512,38 +471,68 @@ public class ArrayDeque This method is equivalent to {@link #removeFirst()}.
*
* @return the element at the front of this deque (which is the top
- * of the stack represented by this deque)
- * @throws NoSuchElementException if this deque is empty
+ * of the stack represented by this deque)
+ * @throws NoSuchElementException {@inheritDoc}
*/
public E pop() {
return removeFirst();
}
+ private void checkInvariants() {
+ assert elements[tail] == null;
+ assert head == tail ? elements[head] == null :
+ (elements[head] != null &&
+ elements[(tail - 1) & (elements.length - 1)] != null);
+ assert elements[(head - 1) & (elements.length - 1)] == null;
+ }
+
/**
- * Remove the element at the specified position in the elements array,
- * adjusting head, tail, and size as necessary. This can result in
- * motion of elements backwards or forwards in the array.
+ * Removes the element at the specified position in the elements array,
+ * adjusting head and tail as necessary. This can result in motion of
+ * elements backwards or forwards in the array.
*
* This method is called delete rather than remove to emphasize
- * that its semantics differ from those of List.remove(int).
+ * that its semantics differ from those of {@link List#remove(int)}.
*
* @return true if elements moved backwards
*/
private boolean delete(int i) {
- // Case 1: Deque doesn't wrap
- // Case 2: Deque does wrap and removed element is in the head portion
- if ((head < tail || tail == 0) || i >= head) {
- System.arraycopy(elements, head, elements, head + 1, i - head);
- elements[head] = null;
- head = (head + 1) & (elements.length - 1);
+ checkInvariants();
+ final E[] elements = this.elements;
+ final int mask = elements.length - 1;
+ final int h = head;
+ final int t = tail;
+ final int front = (i - h) & mask;
+ final int back = (t - i) & mask;
+
+ // Invariant: head <= i < tail mod circularity
+ if (front >= ((t - h) & mask))
+ throw new ConcurrentModificationException();
+
+ // Optimize for least element motion
+ if (front < back) {
+ if (h <= i) {
+ System.arraycopy(elements, h, elements, h + 1, front);
+ } else { // Wrap around
+ System.arraycopy(elements, 0, elements, 1, i);
+ elements[0] = elements[mask];
+ System.arraycopy(elements, h, elements, h + 1, mask - h);
+ }
+ elements[h] = null;
+ head = (h + 1) & mask;
return false;
+ } else {
+ if (i < t) { // Copy the null tail as well
+ System.arraycopy(elements, i + 1, elements, i, back);
+ tail = t - 1;
+ } else { // Wrap around
+ System.arraycopy(elements, i + 1, elements, i, mask - i);
+ elements[mask] = elements[0];
+ System.arraycopy(elements, 1, elements, 0, t);
+ tail = (t - 1) & mask;
+ }
+ return true;
}
-
- // Case 3: Deque wraps and removed element is in the tail portion
- tail--;
- System.arraycopy(elements, i + 1, elements, i, tail - i);
- elements[tail] = null;
- return true;
}
// *** Collection Methods ***
@@ -558,9 +547,9 @@ public class ArrayDeque
+ * Returns true if this deque contains no elements.
*
- * @return true if this collection contains no elements.
+ * @return true if this deque contains no elements
*/
public boolean isEmpty() {
return head == tail;
@@ -572,12 +561,16 @@ public class ArrayDeque This method is equivalent to {@link #removeFirstOccurrence}.
*
- * @param e element to be removed from this deque, if present
+ * @param o element to be removed from this deque, if present
* @return true if this deque contained the specified element
*/
- public boolean remove(Object e) {
- return removeFirstOccurrence(e);
+ public boolean remove(Object o) {
+ return removeFirstOccurrence(o);
}
/**
* Removes all of the elements from this deque.
+ * The deque will be empty after this call returns.
*/
public void clear() {
int h = head;
@@ -670,45 +706,70 @@ public class ArrayDeque The returned array will be "safe" in that no references to it are
+ * maintained by this deque. (In other words, this method must allocate
+ * a new array). The caller is thus free to modify the returned array.
+ *
+ * This method acts as bridge between array-based and collection-based
+ * APIs.
*
* @return an array containing all of the elements in this deque
- * in the correct order
*/
public Object[] toArray() {
- return copyElements(new Object[size()]);
+ return copyElements(new Object[size()]);
}
/**
- * Returns an array containing all of the elements in this deque in the
- * correct order; the runtime type of the returned array is that of the
- * specified array. If the deque fits in the specified array, it is
- * returned therein. Otherwise, a new array is allocated with the runtime
- * type of the specified array and the size of this deque.
+ * Returns an array containing all of the elements in this deque in
+ * proper sequence (from first to last element); the runtime type of the
+ * returned array is that of the specified array. If the deque fits in
+ * the specified array, it is returned therein. Otherwise, a new array
+ * is allocated with the runtime type of the specified array and the
+ * size of this deque.
+ *
+ * If this deque fits in the specified array with room to spare
+ * (i.e., the array has more elements than this deque), the element in
+ * the array immediately following the end of the deque is set to
+ * null.
*
- * If the deque fits in the specified array with room to spare (i.e.,
- * the array has more elements than the deque), the element in the array
- * immediately following the end of the collection is set to null.
+ * Like the {@link #toArray()} method, this method acts as bridge between
+ * array-based and collection-based APIs. Further, this method allows
+ * precise control over the runtime type of the output array, and may,
+ * under certain circumstances, be used to save allocation costs.
+ *
+ * Suppose x is a deque known to contain only strings.
+ * The following code can be used to dump the deque into a newly
+ * allocated array of String:
+ *
+ *
+ * String[] y = x.toArray(new String[0]);
+ *
+ * Note that toArray(new Object[0]) is identical in function to
+ * toArray().
*
* @param a the array into which the elements of the deque are to
- * be stored, if it is big enough; otherwise, a new array of the
- * same runtime type is allocated for this purpose
- * @return an array containing the elements of the deque
- * @throws ArrayStoreException if the runtime type of a is not a supertype
- * of the runtime type of every element in this deque
+ * be stored, if it is big enough; otherwise, a new array of the
+ * same runtime type is allocated for this purpose
+ * @return an array containing all of the elements in this deque
+ * @throws ArrayStoreException if the runtime type of the specified array
+ * is not a supertype of the runtime type of every element in
+ * this deque
+ * @throws NullPointerException if the specified array is null
*/
public