ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/jsr166x/ArrayDeque.java
(Generate patch)

Comparing jsr166/src/jsr166x/ArrayDeque.java (file contents):
Revision 1.1 by dl, Sun Dec 5 21:15:30 2004 UTC vs.
Revision 1.3 by jsr166, Mon Nov 16 04:16:42 2009 UTC

# Line 34 | Line 34 | import java.io.*;
34   * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
35   * as it is, generally speaking, impossible to make any hard guarantees in the
36   * presence of unsynchronized concurrent modification.  Fail-fast iterators
37 < * throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
37 > * throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
38   * Therefore, it would be wrong to write a program that depended on this
39   * exception for its correctness: <i>the fail-fast behavior of iterators
40   * should be used only to detect bugs.</i>
# Line 90 | Line 90 | public class ArrayDeque<E> extends Abstr
90       *
91       * @param numElements  the number of elements to hold.
92       */
93 <    private void allocateElements(int numElements) {  
93 >    private void allocateElements(int numElements) {
94          int initialCapacity = MIN_INITIAL_CAPACITY;
95          // Find the best power of two to hold elements.
96          // Tests "<=" because arrays aren't kept full.
# Line 114 | Line 114 | public class ArrayDeque<E> extends Abstr
114       * when head and tail have wrapped around to become equal.
115       */
116      private void doubleCapacity() {
117 <        assert head == tail;
117 >        assert head == tail;
118          int p = head;
119          int n = elements.length;
120          int r = n - p; // number of elements to the right of p
# Line 194 | Line 194 | public class ArrayDeque<E> extends Abstr
194          if (e == null)
195              throw new NullPointerException();
196          elements[head = (head - 1) & (elements.length - 1)] = e;
197 <        if (head == tail)
197 >        if (head == tail)
198              doubleCapacity();
199      }
200  
# Line 243 | Line 243 | public class ArrayDeque<E> extends Abstr
243          E result = elements[t];
244          if (result == null)
245              return null;
246 <        elements[t] = null;
246 >        elements[t] = null;
247          tail = t;
248          return result;
249      }
# Line 332 | Line 332 | public class ArrayDeque<E> extends Abstr
332       * @return the first element of this deque
333       * @throws NoSuchElementException if this deque is empty
334       */
335 <    public E firstElement() {
335 >    public E getFirst() {
336          E x = elements[head];
337          if (x == null)
338              throw new NoSuchElementException();
# Line 347 | Line 347 | public class ArrayDeque<E> extends Abstr
347       * @return the last element of this deque
348       * @throws NoSuchElementException if this deque is empty
349       */
350 <    public E lastElement() {
350 >    public E getLast() {
351          E x = elements[(tail - 1) & (elements.length - 1)];
352          if (x == null)
353              throw new NoSuchElementException();
# Line 478 | Line 478 | public class ArrayDeque<E> extends Abstr
478       * this deque.  This method differs from the <tt>peek</tt> method only in
479       * that it throws an exception if this deque is empty.
480       *
481 <     * <p>This method is equivalent to {@link #firstElement}
481 >     * <p>This method is equivalent to {@link #getFirst}
482       *
483       * @return the head of the queue represented by this deque
484       * @throws NoSuchElementException if this deque is empty
485       */
486      public E element() {
487 <        return firstElement();
487 >        return getFirst();
488      }
489  
490      // *** Stack methods ***
# Line 523 | Line 523 | public class ArrayDeque<E> extends Abstr
523       *
524       * <p>This method is called delete rather than remove to emphasize the
525       * that that its semantics differ from those of List.remove(int).
526 <     *
526 >     *
527       * @return true if elements moved backwards
528       */
529      private boolean delete(int i) {
# Line 568 | Line 568 | public class ArrayDeque<E> extends Abstr
568       * will be ordered from first (head) to last (tail).  This is the same
569       * order that elements would be dequeued (via successive calls to
570       * {@link #remove} or popped (via successive calls to {@link #pop}).
571 <     *
571 >     *
572       * @return an <tt>Iterator</tt> over the elements in this deque
573       */
574      public Iterator<E> iterator() {
# Line 719 | Line 719 | public class ArrayDeque<E> extends Abstr
719       * @return a copy of this deque
720       */
721      public ArrayDeque<E> clone() {
722 <        try {
722 >        try {
723              ArrayDeque<E> result = (ArrayDeque<E>) super.clone();
724              // These two lines are currently faster than cloning the array:
725              result.elements = (E[]) new Object[elements.length];
726              System.arraycopy(elements, 0, result.elements, 0, elements.length);
727              return result;
728  
729 <        } catch (CloneNotSupportedException e) {
729 >        } catch (CloneNotSupportedException e) {
730              throw new AssertionError();
731          }
732      }

Diff Legend

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