--- jsr166/src/main/java/util/ArrayList.java	2016/11/13 21:07:40	1.41
+++ jsr166/src/main/java/util/ArrayList.java	2016/11/16 00:17:25	1.44
@@ -912,25 +912,21 @@ public class ArrayList<E> extends Abstra
         }
 
         @Override
-        @SuppressWarnings("unchecked")
-        public void forEachRemaining(Consumer<? super E> consumer) {
-            Objects.requireNonNull(consumer);
+        public void forEachRemaining(Consumer<? super E> action) {
+            Objects.requireNonNull(action);
             final int size = ArrayList.this.size;
             int i = cursor;
-            if (i >= size) {
-                return;
-            }
-            final Object[] elementData = ArrayList.this.elementData;
-            if (i >= elementData.length) {
-                throw new ConcurrentModificationException();
-            }
-            while (i != size && modCount == expectedModCount) {
-                consumer.accept((E) elementData[i++]);
+            if (i < size) {
+                final Object[] es = elementData;
+                if (i >= es.length)
+                    throw new ConcurrentModificationException();
+                for (; i < size && modCount == expectedModCount; i++)
+                    action.accept(elementAt(es, i));
+                // update once at end to reduce heap write traffic
+                cursor = i;
+                lastRet = i - 1;
+                checkForComodification();
             }
-            // update once at end of iteration to reduce heap write traffic
-            cursor = i;
-            lastRet = i - 1;
-            checkForComodification();
         }
 
         final void checkForComodification() {
@@ -1191,24 +1187,21 @@ public class ArrayList<E> extends Abstra
                     return (E) elementData[offset + (lastRet = i)];
                 }
 
-                @SuppressWarnings("unchecked")
-                public void forEachRemaining(Consumer<? super E> consumer) {
-                    Objects.requireNonNull(consumer);
+                public void forEachRemaining(Consumer<? super E> action) {
+                    Objects.requireNonNull(action);
                     final int size = SubList.this.size;
                     int i = cursor;
-                    if (i >= size) {
-                        return;
-                    }
-                    final Object[] elementData = root.elementData;
-                    if (offset + i >= elementData.length) {
-                        throw new ConcurrentModificationException();
-                    }
-                    while (i != size && modCount == expectedModCount) {
-                        consumer.accept((E) elementData[offset + (i++)]);
+                    if (i < size) {
+                        final Object[] es = root.elementData;
+                        if (offset + i >= es.length)
+                            throw new ConcurrentModificationException();
+                        for (; i < size && modCount == expectedModCount; i++)
+                            action.accept(elementAt(es, offset + i));
+                        // update once at end to reduce heap write traffic
+                        cursor = i;
+                        lastRet = i - 1;
+                        checkForComodification();
                     }
-                    // update once at end of iteration to reduce heap write traffic
-                    lastRet = cursor = i;
-                    checkForComodification();
                 }
 
                 public int nextIndex() {
@@ -1536,22 +1529,21 @@ public class ArrayList<E> extends Abstra
         return removeIf(filter, 0, size);
     }
 
-    boolean removeIf(Predicate<? super E> filter,
-                     final int from, final int end) {
+    /**
+     * Removes all elements satisfying the given predicate, from index
+     * i (inclusive) to index end (exclusive).
+     */
+    boolean removeIf(Predicate<? super E> filter, int i, final int end) {
         Objects.requireNonNull(filter);
         int expectedModCount = modCount;
         final Object[] es = elementData;
-        final boolean modified;
-        int i;
         // Optimize for initial run of survivors
-        for (i = from; i < end && !filter.test(elementAt(es, i)); i++)
+        for (; i < end && !filter.test(elementAt(es, i)); i++)
             ;
         // Tolerate predicates that reentrantly access the collection for
         // read (but writers still get CME), so traverse once to find
         // elements to delete, a second pass to physically expunge.
-        if (modified = (i < end)) {
-            expectedModCount++;
-            modCount++;
+        if (i < end) {
             final int beg = i;
             final long[] deathRow = nBits(end - beg);
             deathRow[0] = 1L;   // set bit 0
@@ -1560,6 +1552,8 @@ public class ArrayList<E> extends Abstra
                     setBit(deathRow, i - beg);
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
+            expectedModCount++;
+            modCount++;
             int w = beg;
             for (i = beg; i < end; i++)
                 if (isClear(deathRow, i - beg))
@@ -1567,11 +1561,14 @@ public class ArrayList<E> extends Abstra
             final int oldSize = size;
             System.arraycopy(es, end, es, w, oldSize - end);
             Arrays.fill(es, size -= (end - w), oldSize, null);
+            // checkInvariants();
+            return true;
+        } else {
+            if (modCount != expectedModCount)
+                throw new ConcurrentModificationException();
+            // checkInvariants();
+            return false;
         }
-        if (modCount != expectedModCount)
-            throw new ConcurrentModificationException();
-        // checkInvariants();
-        return modified;
     }
 
     @Override