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> |
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. |
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 |
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 |
|
|
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 |
|
} |
504 |
|
|
505 |
|
/** |
506 |
|
* Pops an element from the stack represented by this deque. In other |
507 |
< |
* words, removes and returns the the first element of this deque. |
507 |
> |
* words, removes and returns the first element of this deque. |
508 |
|
* |
509 |
|
* <p>This method is equivalent to {@link #removeFirst()}. |
510 |
|
* |
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) { |
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() { |
676 |
|
* in the correct order. |
677 |
|
* |
678 |
|
* @return an array containing all of the elements in this list |
679 |
< |
* in the correct order |
679 |
> |
* in the correct order |
680 |
|
*/ |
681 |
|
public Object[] toArray() { |
682 |
< |
return copyElements(new Object[size()]); |
682 |
> |
return copyElements(new Object[size()]); |
683 |
|
} |
684 |
|
|
685 |
|
/** |
694 |
|
* immediately following the end of the collection is set to <tt>null</tt>. |
695 |
|
* |
696 |
|
* @param a the array into which the elements of the deque are to |
697 |
< |
* be stored, if it is big enough; otherwise, a new array of the |
698 |
< |
* same runtime type is allocated for this purpose |
697 |
> |
* be stored, if it is big enough; otherwise, a new array of the |
698 |
> |
* same runtime type is allocated for this purpose |
699 |
|
* @return an array containing the elements of the deque |
700 |
|
* @throws ArrayStoreException if the runtime type of a is not a supertype |
701 |
|
* of the runtime type of every element in this deque |
705 |
|
if (a.length < size) |
706 |
|
a = (T[])java.lang.reflect.Array.newInstance( |
707 |
|
a.getClass().getComponentType(), size); |
708 |
< |
copyElements(a); |
708 |
> |
copyElements(a); |
709 |
|
if (a.length > size) |
710 |
|
a[size] = null; |
711 |
|
return a; |
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 |
|
} |