--- jsr166/src/main/java/util/ArrayList.java	2016/10/18 22:15:15	1.35
+++ jsr166/src/main/java/util/ArrayList.java	2016/11/04 03:09:27	1.37
@@ -716,7 +716,6 @@ public class ArrayList<E> extends Abstra
      * @see Collection#contains(Object)
      */
     public boolean removeAll(Collection<?> c) {
-        Objects.requireNonNull(c);
         return batchRemove(c, false);
     }
 
@@ -737,34 +736,34 @@ public class ArrayList<E> extends Abstra
      * @see Collection#contains(Object)
      */
     public boolean retainAll(Collection<?> c) {
-        Objects.requireNonNull(c);
         return batchRemove(c, true);
     }
 
     private boolean batchRemove(Collection<?> c, boolean complement) {
-        final Object[] elementData = this.elementData;
-        int r = 0, w = 0;
-        boolean modified = false;
-        try {
-            for (; r < size; r++)
-                if (c.contains(elementData[r]) == complement)
-                    elementData[w++] = elementData[r];
-        } finally {
-            // Preserve behavioral compatibility with AbstractCollection,
-            // even if c.contains() throws.
-            if (r != size) {
-                System.arraycopy(elementData, r,
-                                 elementData, w,
-                                 size - r);
+        Objects.requireNonNull(c);
+        final Object[] es = elementData;
+        final int size = this.size;
+        final boolean modified;
+        int r;
+        // Optimize for initial run of survivors
+        for (r = 0; r < size; r++)
+            if (c.contains(es[r]) != complement)
+                break;
+        if (modified = (r < size)) {
+            int w = r++;
+            try {
+                for (Object e; r < size; r++)
+                    if (c.contains(e = es[r]) == complement)
+                        es[w++] = e;
+            } catch (Throwable ex) {
+                // Preserve behavioral compatibility with AbstractCollection,
+                // even if c.contains() throws.
+                System.arraycopy(es, r, es, w, size - r);
                 w += size - r;
-            }
-            if (w != size) {
-                // clear to let GC do its work
-                for (int i = w; i < size; i++)
-                    elementData[i] = null;
+                throw ex;
+            } finally {
                 modCount += size - w;
-                size = w;
-                modified = true;
+                Arrays.fill(es, (this.size = w), size, null);
             }
         }
         return modified;
@@ -1494,39 +1493,39 @@ public class ArrayList<E> extends Abstra
         }
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public boolean removeIf(Predicate<? super E> filter) {
         Objects.requireNonNull(filter);
-        final int expectedModCount = modCount;
-        final Object[] elementData = this.elementData;
-        int r = 0, w = 0, remaining = size, deleted = 0;
-        try {
-            for (; remaining > 0; remaining--, r++) {
-                @SuppressWarnings("unchecked") E e = (E) elementData[r];
-                if (filter.test(e))
-                    deleted++;
-                else {
-                    if (r != w)
-                        elementData[w] = e;
-                    w++;
-                }
-            }
-            if (modCount != expectedModCount)
-                throw new ConcurrentModificationException();
-            return deleted > 0;
-        } catch (Throwable ex) {
-            if (deleted > 0)
-                for (; remaining > 0; remaining--, r++, w++)
-                    elementData[w] = elementData[r];
-            throw ex;
-        } finally {
-            if (deleted > 0) {
-                modCount++;
-                size -= deleted;
-                while (--deleted >= 0)
-                    elementData[w++] = null;
+        int expectedModCount = modCount;
+        final Object[] es = elementData;
+        final int size = this.size;
+        final boolean modified;
+        int r;
+        // Optimize for initial run of survivors
+        for (r = 0; r < size; r++)
+            if (filter.test((E) es[r]))
+                break;
+        if (modified = (r < size)) {
+            expectedModCount++;
+            modCount++;
+            int w = r++;
+            try {
+                for (E e; r < size; r++)
+                    if (!filter.test(e = (E) es[r]))
+                        es[w++] = e;
+            } catch (Throwable ex) {
+                // copy remaining elements
+                System.arraycopy(es, r, es, w, size - r);
+                w += size - r;
+                throw ex;
+            } finally {
+                Arrays.fill(es, (this.size = w), size, null);
             }
         }
+        if (modCount != expectedModCount)
+            throw new ConcurrentModificationException();
+        return modified;
     }
 
     @Override