--- jsr166/src/main/java/util/ArrayDeque.java	2016/10/18 20:32:55	1.79
+++ jsr166/src/main/java/util/ArrayDeque.java	2016/10/23 00:28:41	1.83
@@ -134,8 +134,9 @@ public class ArrayDeque<E> extends Abstr
      * to ensure that it can hold at least the given number of elements.
      *
      * @param minCapacity the desired minimum capacity
+     * @since TBD
      */
-    /* TODO: public */ private void ensureCapacity(int minCapacity) {
+    /* public */ void ensureCapacity(int minCapacity) {
         if (minCapacity > elements.length)
             grow(minCapacity - elements.length);
         // checkInvariants();
@@ -143,8 +144,10 @@ public class ArrayDeque<E> extends Abstr
 
     /**
      * Minimizes the internal storage of this collection.
+     *
+     * @since TBD
      */
-    /* TODO: public */ private void trimToSize() {
+    /* public */ void trimToSize() {
         if (size < elements.length) {
             elements = toArray();
             head = 0;
@@ -260,12 +263,20 @@ public class ArrayDeque<E> extends Abstr
     public void addFirst(E e) {
         // checkInvariants();
         Objects.requireNonNull(e);
-        Object[] elements;
-        int capacity, s = size;
-        while (s == (capacity = (elements = this.elements).length))
-            grow(1);
-        elements[head = dec(head, capacity)] = e;
+        final Object[] elements;
+        final int capacity, s;
+        if ((s = size) == (capacity = (elements = this.elements).length))
+            addFirstSlowPath(e);
+        else
+            elements[head = dec(head, capacity)] = e;
         size = s + 1;
+        // checkInvariants();
+    }
+
+    private void addFirstSlowPath(E e) {
+        grow(1);
+        final Object[] elements = this.elements;
+        elements[head = dec(head, elements.length)] = e;
     }
 
     /**
@@ -279,12 +290,20 @@ public class ArrayDeque<E> extends Abstr
     public void addLast(E e) {
         // checkInvariants();
         Objects.requireNonNull(e);
-        Object[] elements;
-        int capacity, s = size;
-        while (s == (capacity = (elements = this.elements).length))
-            grow(1);
-        elements[add(head, s, capacity)] = e;
+        final Object[] elements;
+        final int capacity, s;
+        if ((s = size) == (capacity = (elements = this.elements).length))
+            addLastSlowPath(e);
+        else
+            elements[add(head, s, capacity)] = e;
         size = s + 1;
+        // checkInvariants();
+    }
+
+    private void addLastSlowPath(E e) {
+        grow(1);
+        final Object[] elements = this.elements;
+        elements[add(head, size, elements.length)] = e;
     }
 
     /**
@@ -686,44 +705,39 @@ public class ArrayDeque<E> extends Abstr
 
         DeqIterator() { cursor = head; }
 
-        int advance(int i, int modulus) {
-            return inc(i, modulus);
-        }
-
-        void doRemove() {
-            if (delete(lastRet))
-                // if left-shifted, undo advance in next()
-                cursor = dec(cursor, elements.length);
-        }
-
         public final boolean hasNext() {
             return remaining > 0;
         }
 
-        public final E next() {
+        public E next() {
             if (remaining == 0)
                 throw new NoSuchElementException();
             E e = checkedElementAt(elements, cursor);
             lastRet = cursor;
-            cursor = advance(cursor, elements.length);
+            cursor = inc(cursor, elements.length);
             remaining--;
             return e;
         }
 
+        void postDelete(boolean leftShifted) {
+            if (leftShifted)
+                cursor = dec(cursor, elements.length); // undo inc in next
+        }
+
         public final void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
-            doRemove();
+            postDelete(delete(lastRet));
             lastRet = -1;
         }
 
-        public final void forEachRemaining(Consumer<? super E> action) {
+        public void forEachRemaining(Consumer<? super E> action) {
             Objects.requireNonNull(action);
             final Object[] elements = ArrayDeque.this.elements;
             final int capacity = elements.length;
             int k = remaining;
             remaining = 0;
-            for (int i = cursor; --k >= 0; i = advance(i, capacity))
+            for (int i = cursor; --k >= 0; i = inc(i, capacity))
                 action.accept(checkedElementAt(elements, i));
         }
     }
@@ -731,14 +745,29 @@ public class ArrayDeque<E> extends Abstr
     private class DescendingIterator extends DeqIterator {
         DescendingIterator() { cursor = tail(); }
 
-        @Override int advance(int i, int modulus) {
-            return dec(i, modulus);
+        public final E next() {
+            if (remaining == 0)
+                throw new NoSuchElementException();
+            E e = checkedElementAt(elements, cursor);
+            lastRet = cursor;
+            cursor = dec(cursor, elements.length);
+            remaining--;
+            return e;
+        }
+
+        void postDelete(boolean leftShifted) {
+            if (!leftShifted)
+                cursor = inc(cursor, elements.length); // undo dec in next
         }
 
-        @Override void doRemove() {
-            if (!delete(lastRet))
-                // if right-shifted, undo advance in next
-                cursor = inc(cursor, elements.length);
+        public final void forEachRemaining(Consumer<? super E> action) {
+            Objects.requireNonNull(action);
+            final Object[] elements = ArrayDeque.this.elements;
+            final int capacity = elements.length;
+            int k = remaining;
+            remaining = 0;
+            for (int i = cursor; --k >= 0; i = dec(i, capacity))
+                action.accept(checkedElementAt(elements, i));
         }
     }
 
@@ -842,8 +871,9 @@ public class ArrayDeque<E> extends Abstr
      * operator to that element, as specified by {@link List#replaceAll}.
      *
      * @param operator the operator to apply to each element
+     * @since TBD
      */
-    /* TODO: public */ private void replaceAll(UnaryOperator<E> operator) {
+    /* public */ void replaceAll(UnaryOperator<E> operator) {
         Objects.requireNonNull(operator);
         final Object[] elements = this.elements;
         final int capacity = elements.length;