public ArrayDeque() 
{
        elements = (E[]) new Object[16];
}

Constructs an empty array deque with an initial capacity sufficient to hold 16 elements.

 public ArrayDeque(int numElements) 
{
        allocateElements(numElements);
}

Constructs an empty array deque with an initial capacity sufficient to hold the specified number of elements.

Parameters:

numElements - lower bound on initial capacity of the deque

 public ArrayDeque(Collection c) 
{
        allocateElements(c.size());
        addAll(c);
}

Constructs a deque containing the elements of the specified collection, in the order they are returned by the collection's iterator. (The first element returned by the collection's iterator becomes the first element, or front of the deque.)

Parameters:

c - the collection whose elements are to be placed into the deque

Throws:

NullPointerException - if the specified collection is null

 public boolean add(E e) 
{
        addLast(e);
        return true;
}

Inserts the specified element at the end of this deque.

This method is equivalent to #addLast .

 public  void addFirst(E e) 
{
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
}

Inserts the specified element at the front of this deque.

 public  void addLast(E e) 
{
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
}

Inserts the specified element at the end of this deque.

This method is equivalent to #add .

 public  void clear() 
{
        int h = head;
        int t = tail;
        if (h != t) { // clear all cells
            head = tail = 0;
            int i = h;
            int mask = elements.length - 1;
            do {
                elements[i] = null;
                i = (i + 1) & mask;
            } while (i != t);
        }
}

Removes all of the elements from this deque. The deque will be empty after this call returns.

 public ArrayDeque clone() 
{
        try {
            ArrayDeque< E > result = (ArrayDeque< E >) super.clone();
            result.elements = Arrays.copyOf(elements, elements.length);
            return result;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
}

Returns a copy of this deque.

 public boolean contains(Object o) 
{
        if (o == null)
            return false;
        int mask = elements.length - 1;
        int i = head;
        E x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x))
                return true;
            i = (i + 1) & mask;
        }
        return false;
}

Returns true if this deque contains the specified element. More formally, returns true if and only if this deque contains at least one element e such that o.equals(e).

 public Iterator descendingIterator() 
{
        return new DescendingIterator();
}

 public E element() 
{
        return getFirst();
}

Retrieves, but does not remove, the head of the queue represented by this deque. This method differs from peek only in that it throws an exception if this deque is empty.

This method is equivalent to #getFirst .

 public E getFirst() 
{
        E x = elements[head];
        if (x == null)
            throw new NoSuchElementException();
        return x;
}

 public E getLast() 
{
        E x = elements[(tail - 1) & (elements.length - 1)];
        if (x == null)
            throw new NoSuchElementException();
        return x;
}

 public boolean isEmpty() 
{
        return head == tail;
}

Returns true if this deque contains no elements.

 public Iterator iterator() 
{
        return new DeqIterator();
}

Returns an iterator over the elements in this deque. The elements will be ordered from first (head) to last (tail). This is the same order that elements would be dequeued (via successive calls to #remove or popped (via successive calls to #pop ).

 public boolean offer(E e) 
{
        return offerLast(e);
}

Inserts the specified element at the end of this deque.

This method is equivalent to #offerLast .

 public boolean offerFirst(E e) 
{
        addFirst(e);
        return true;
}

Inserts the specified element at the front of this deque.

 public boolean offerLast(E e) 
{
        addLast(e);
        return true;
}

Inserts the specified element at the end of this deque.

 public E peek() 
{
        return peekFirst();
}

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 #peekFirst .

 public E peekFirst() 
{
        return elements[head]; // elements[head] is null if deque empty
}

 public E peekLast() 
{
        return elements[(tail - 1) & (elements.length - 1)];
}

 public E poll() 
{
        return pollFirst();
}

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 #pollFirst .

 public E pollFirst() 
{
        int h = head;
        E result = elements[h]; // Element is null if deque empty
        if (result == null)
            return null;
        elements[h] = null;     // Must null out slot
        head = (h + 1) & (elements.length - 1);
        return result;
}

 public E pollLast() 
{
        int t = (tail - 1) & (elements.length - 1);
        E result = elements[t];
        if (result == null)
            return null;
        elements[t] = null;
        tail = t;
        return result;
}

 public E pop() 
{
        return removeFirst();
}

Pops an element from the stack represented by this deque. In other words, removes and returns the first element of this deque.

This method is equivalent to #removeFirst() .

 public  void push(E e) 
{
        addFirst(e);
}

Pushes an element onto the stack represented by this deque. In other words, inserts the element at the front of this deque.

This method is equivalent to #addFirst .

 public E remove() 
{
        return removeFirst();
}

Retrieves and removes the head of the queue represented by this deque. This method differs from poll only in that it throws an exception if this deque is empty.

This method is equivalent to #removeFirst .

 public boolean remove(Object o) 
{
        return removeFirstOccurrence(o);
}

Removes a single instance of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the first element e such that o.equals(e) (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).

This method is equivalent to #removeFirstOccurrence .

 public E removeFirst() 
{
        E x = pollFirst();
        if (x == null)
            throw new NoSuchElementException();
        return x;
}

 public boolean removeFirstOccurrence(Object o) 
{
        if (o == null)
            return false;
        int mask = elements.length - 1;
        int i = head;
        E x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x)) {
                delete(i);
                return true;
            }
            i = (i + 1) & mask;
        }
        return false;
}

Removes the first occurrence of the specified element in this deque (when traversing the deque from head to tail). If the deque does not contain the element, it is unchanged. More formally, removes the first element e such that o.equals(e) (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).

 public E removeLast() 
{
        E x = pollLast();
        if (x == null)
            throw new NoSuchElementException();
        return x;
}

 public boolean removeLastOccurrence(Object o) 
{
        if (o == null)
            return false;
        int mask = elements.length - 1;
        int i = (tail - 1) & mask;
        E x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x)) {
                delete(i);
                return true;
            }
            i = (i - 1) & mask;
        }
        return false;
}

Removes the last occurrence of the specified element in this deque (when traversing the deque from head to tail). If the deque does not contain the element, it is unchanged. More formally, removes the last element e such that o.equals(e) (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).

 public int size() 
{
        return (tail - head) & (elements.length - 1);
}

Returns the number of elements in this deque.

 public Object[] toArray() 
{
        return copyElements(new Object[size()]);
}

Returns an array containing all of the elements in this deque in proper sequence (from first to last element).

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.

 public T[] toArray(T[] a) 
{
        int size = size();
        if (a.length <  size)
            a = (T[])java.lang.reflect.Array.newInstance(
                    a.getClass().getComponentType(), size);
        copyElements(a);
        if (a.length  > size)
            a[size] = null;
        return a;
}

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.

Like the #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().