--- jsr166/src/main/java/util/PriorityQueue.java 2013/02/18 03:15:10 1.92
+++ jsr166/src/main/java/util/PriorityQueue.java 2018/05/06 23:29:25 1.128
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -24,9 +24,10 @@
*/
package java.util;
+
import java.util.function.Consumer;
-import java.util.stream.Stream;
-import java.util.stream.Streams;
+import java.util.function.Predicate;
+import jdk.internal.misc.SharedSecrets;
/**
* An unbounded priority {@linkplain Queue queue} based on a priority heap.
@@ -55,7 +56,8 @@ import java.util.stream.Streams;
*
This class and its iterator implement all of the
* optional methods of the {@link Collection} and {@link
* Iterator} interfaces. The Iterator provided in method {@link
- * #iterator()} is not guaranteed to traverse the elements of
+ * #iterator()} and the Spliterator provided in method {@link #spliterator()}
+ * are not guaranteed to traverse the elements of
* the priority queue in any particular order. If you need ordered
* traversal, consider using {@code Arrays.sort(pq.toArray())}.
*
@@ -66,20 +68,21 @@ import java.util.stream.Streams;
* java.util.concurrent.PriorityBlockingQueue} class.
*
*
Implementation note: this implementation provides
- * O(log(n)) time for the enqueing and dequeing methods
+ * O(log(n)) time for the enqueuing and dequeuing methods
* ({@code offer}, {@code poll}, {@code remove()} and {@code add});
* linear time for the {@code remove(Object)} and {@code contains(Object)}
* methods; and constant time for the retrieval methods
* ({@code peek}, {@code element}, and {@code size}).
*
*
This class is a member of the
- *
+ *
* Java Collections Framework.
*
* @since 1.5
* @author Josh Bloch, Doug Lea
- * @param the type of elements held in this collection
+ * @param the type of elements held in this queue
*/
+@SuppressWarnings("unchecked")
public class PriorityQueue extends AbstractQueue
implements java.io.Serializable {
@@ -100,7 +103,7 @@ public class PriorityQueue extends Ab
/**
* The number of elements in the priority queue.
*/
- private int size = 0;
+ int size;
/**
* The comparator, or null if priority queue uses elements'
@@ -112,7 +115,7 @@ public class PriorityQueue extends Ab
* The number of times this priority queue has been
* structurally modified. See AbstractList for gory details.
*/
- transient int modCount = 0; // non-private to simplify nested class access
+ transient int modCount; // non-private to simplify nested class access
/**
* Creates a {@code PriorityQueue} with the default initial
@@ -137,6 +140,19 @@ public class PriorityQueue extends Ab
}
/**
+ * Creates a {@code PriorityQueue} with the default initial capacity and
+ * whose elements are ordered according to the specified comparator.
+ *
+ * @param comparator the comparator that will be used to order this
+ * priority queue. If {@code null}, the {@linkplain Comparable
+ * natural ordering} of the elements will be used.
+ * @since 1.8
+ */
+ public PriorityQueue(Comparator super E> comparator) {
+ this(DEFAULT_INITIAL_CAPACITY, comparator);
+ }
+
+ /**
* Creates a {@code PriorityQueue} with the specified initial capacity
* that orders its elements according to the specified comparator.
*
@@ -173,7 +189,6 @@ public class PriorityQueue extends Ab
* @throws NullPointerException if the specified collection or any
* of its elements are null
*/
- @SuppressWarnings("unchecked")
public PriorityQueue(Collection extends E> c) {
if (c instanceof SortedSet>) {
SortedSet extends E> ss = (SortedSet extends E>) c;
@@ -205,7 +220,6 @@ public class PriorityQueue extends Ab
* @throws NullPointerException if the specified priority queue or any
* of its elements are null
*/
- @SuppressWarnings("unchecked")
public PriorityQueue(PriorityQueue extends E> c) {
this.comparator = (Comparator super E>) c.comparator();
initFromPriorityQueue(c);
@@ -224,15 +238,19 @@ public class PriorityQueue extends Ab
* @throws NullPointerException if the specified sorted set or any
* of its elements are null
*/
- @SuppressWarnings("unchecked")
public PriorityQueue(SortedSet extends E> c) {
this.comparator = (Comparator super E>) c.comparator();
initElementsFromCollection(c);
}
+ /** Ensures that queue[0] exists, helping peek() and poll(). */
+ private static Object[] ensureNonEmpty(Object[] es) {
+ return (es.length > 0) ? es : new Object[1];
+ }
+
private void initFromPriorityQueue(PriorityQueue extends E> c) {
if (c.getClass() == PriorityQueue.class) {
- this.queue = c.toArray();
+ this.queue = ensureNonEmpty(c.toArray());
this.size = c.size();
} else {
initFromCollection(c);
@@ -240,17 +258,17 @@ public class PriorityQueue extends Ab
}
private void initElementsFromCollection(Collection extends E> c) {
- Object[] a = c.toArray();
+ Object[] es = c.toArray();
+ int len = es.length;
// If c.toArray incorrectly doesn't return Object[], copy it.
- if (a.getClass() != Object[].class)
- a = Arrays.copyOf(a, a.length, Object[].class);
- int len = a.length;
+ if (es.getClass() != Object[].class)
+ es = Arrays.copyOf(es, len, Object[].class);
if (len == 1 || this.comparator != null)
- for (int i = 0; i < len; i++)
- if (a[i] == null)
+ for (Object e : es)
+ if (e == null)
throw new NullPointerException();
- this.queue = a;
- this.size = a.length;
+ this.queue = ensureNonEmpty(es);
+ this.size = len;
}
/**
@@ -325,23 +343,20 @@ public class PriorityQueue extends Ab
int i = size;
if (i >= queue.length)
grow(i + 1);
+ siftUp(i, e);
size = i + 1;
- if (i == 0)
- queue[0] = e;
- else
- siftUp(i, e);
return true;
}
- @SuppressWarnings("unchecked")
public E peek() {
- return (size == 0) ? null : (E) queue[0];
+ return (E) queue[0];
}
private int indexOf(Object o) {
if (o != null) {
- for (int i = 0; i < size; i++)
- if (o.equals(queue[i]))
+ final Object[] es = queue;
+ for (int i = 0, n = size; i < n; i++)
+ if (o.equals(es[i]))
return i;
}
return -1;
@@ -369,20 +384,18 @@ public class PriorityQueue extends Ab
}
/**
- * Version of remove using reference equality, not equals.
- * Needed by iterator.remove.
+ * Identity-based version for use in Itr.remove.
*
* @param o element to be removed from this queue, if present
- * @return {@code true} if removed
*/
- boolean removeEq(Object o) {
- for (int i = 0; i < size; i++) {
- if (o == queue[i]) {
+ void removeEq(Object o) {
+ final Object[] es = queue;
+ for (int i = 0, n = size; i < n; i++) {
+ if (o == es[i]) {
removeAt(i);
- return true;
+ break;
}
}
- return false;
}
/**
@@ -394,7 +407,7 @@ public class PriorityQueue extends Ab
* @return {@code true} if this queue contains the specified element
*/
public boolean contains(Object o) {
- return indexOf(o) != -1;
+ return indexOf(o) >= 0;
}
/**
@@ -436,7 +449,7 @@ public class PriorityQueue extends Ab
* The following code can be used to dump the queue into a newly
* allocated array of {@code String}:
*
- * {@code String[] y = x.toArray(new String[0]);}
+ * {@code String[] y = x.toArray(new String[0]);}
*
* Note that {@code toArray(new Object[0])} is identical in function to
* {@code toArray()}.
@@ -450,7 +463,6 @@ public class PriorityQueue extends Ab
* this queue
* @throws NullPointerException if the specified array is null
*/
- @SuppressWarnings("unchecked")
public T[] toArray(T[] a) {
final int size = this.size;
if (a.length < size)
@@ -477,7 +489,7 @@ public class PriorityQueue extends Ab
* Index (into queue array) of element to be returned by
* subsequent call to next.
*/
- private int cursor = 0;
+ private int cursor;
/**
* Index of element returned by most recent call to next,
@@ -497,13 +509,13 @@ public class PriorityQueue extends Ab
* We expect that most iterations, even those involving removals,
* will not need to store elements in this field.
*/
- private ArrayDeque forgetMeNot = null;
+ private ArrayDeque forgetMeNot;
/**
* Element returned by the most recent call to next iff that
* element was drawn from the forgetMeNot list.
*/
- private E lastRetElt = null;
+ private E lastRetElt;
/**
* The modCount value that the iterator believes that the backing
@@ -512,12 +524,13 @@ public class PriorityQueue extends Ab
*/
private int expectedModCount = modCount;
+ Itr() {} // prevent access constructor creation
+
public boolean hasNext() {
return cursor < size ||
(forgetMeNot != null && !forgetMeNot.isEmpty());
}
- @SuppressWarnings("unchecked")
public E next() {
if (expectedModCount != modCount)
throw new ConcurrentModificationException();
@@ -565,22 +578,29 @@ public class PriorityQueue extends Ab
*/
public void clear() {
modCount++;
- for (int i = 0; i < size; i++)
- queue[i] = null;
+ final Object[] es = queue;
+ for (int i = 0, n = size; i < n; i++)
+ es[i] = null;
size = 0;
}
- @SuppressWarnings("unchecked")
public E poll() {
- if (size == 0)
- return null;
- int s = --size;
- modCount++;
- E result = (E) queue[0];
- E x = (E) queue[s];
- queue[s] = null;
- if (s != 0)
- siftDown(0, x);
+ final Object[] es;
+ final E result;
+
+ if ((result = (E) ((es = queue)[0])) != null) {
+ modCount++;
+ final int n;
+ final E x = (E) es[(n = --size)];
+ es[n] = null;
+ if (n > 0) {
+ final Comparator super E> cmp;
+ if ((cmp = comparator) == null)
+ siftDownComparable(0, x, es, n);
+ else
+ siftDownUsingComparator(0, x, es, n, cmp);
+ }
+ }
return result;
}
@@ -596,20 +616,20 @@ public class PriorityQueue extends Ab
* position before i. This fact is used by iterator.remove so as to
* avoid missing traversing elements.
*/
- @SuppressWarnings("unchecked")
- private E removeAt(int i) {
+ E removeAt(int i) {
// assert i >= 0 && i < size;
+ final Object[] es = queue;
modCount++;
int s = --size;
if (s == i) // removed last element
- queue[i] = null;
+ es[i] = null;
else {
- E moved = (E) queue[s];
- queue[s] = null;
+ E moved = (E) es[s];
+ es[s] = null;
siftDown(i, moved);
- if (queue[i] == moved) {
+ if (es[i] == moved) {
siftUp(i, moved);
- if (queue[i] != moved)
+ if (es[i] != moved)
return moved;
}
}
@@ -621,7 +641,7 @@ public class PriorityQueue extends Ab
* promoting x up the tree until it is greater than or equal to
* its parent, or is the root.
*
- * To simplify and speed up coercions and comparisons. the
+ * To simplify and speed up coercions and comparisons, the
* Comparable and Comparator versions are separated into different
* methods that are otherwise identical. (Similarly for siftDown.)
*
@@ -630,36 +650,35 @@ public class PriorityQueue extends Ab
*/
private void siftUp(int k, E x) {
if (comparator != null)
- siftUpUsingComparator(k, x);
+ siftUpUsingComparator(k, x, queue, comparator);
else
- siftUpComparable(k, x);
+ siftUpComparable(k, x, queue);
}
- @SuppressWarnings("unchecked")
- private void siftUpComparable(int k, E x) {
- Comparable super E> key = (Comparable super E>) x;
+ private static void siftUpComparable(int k, T x, Object[] es) {
+ Comparable super T> key = (Comparable super T>) x;
while (k > 0) {
int parent = (k - 1) >>> 1;
- Object e = queue[parent];
- if (key.compareTo((E) e) >= 0)
+ Object e = es[parent];
+ if (key.compareTo((T) e) >= 0)
break;
- queue[k] = e;
+ es[k] = e;
k = parent;
}
- queue[k] = key;
+ es[k] = key;
}
- @SuppressWarnings("unchecked")
- private void siftUpUsingComparator(int k, E x) {
+ private static void siftUpUsingComparator(
+ int k, T x, Object[] es, Comparator super T> cmp) {
while (k > 0) {
int parent = (k - 1) >>> 1;
- Object e = queue[parent];
- if (comparator.compare(x, (E) e) >= 0)
+ Object e = es[parent];
+ if (cmp.compare(x, (T) e) >= 0)
break;
- queue[k] = e;
+ es[k] = e;
k = parent;
}
- queue[k] = x;
+ es[k] = x;
}
/**
@@ -672,56 +691,63 @@ public class PriorityQueue extends Ab
*/
private void siftDown(int k, E x) {
if (comparator != null)
- siftDownUsingComparator(k, x);
+ siftDownUsingComparator(k, x, queue, size, comparator);
else
- siftDownComparable(k, x);
+ siftDownComparable(k, x, queue, size);
}
- @SuppressWarnings("unchecked")
- private void siftDownComparable(int k, E x) {
- Comparable super E> key = (Comparable super E>)x;
- int half = size >>> 1; // loop while a non-leaf
+ private static void siftDownComparable(int k, T x, Object[] es, int n) {
+ // assert n > 0;
+ Comparable super T> key = (Comparable super T>)x;
+ int half = n >>> 1; // loop while a non-leaf
while (k < half) {
int child = (k << 1) + 1; // assume left child is least
- Object c = queue[child];
+ Object c = es[child];
int right = child + 1;
- if (right < size &&
- ((Comparable super E>) c).compareTo((E) queue[right]) > 0)
- c = queue[child = right];
- if (key.compareTo((E) c) <= 0)
+ if (right < n &&
+ ((Comparable super T>) c).compareTo((T) es[right]) > 0)
+ c = es[child = right];
+ if (key.compareTo((T) c) <= 0)
break;
- queue[k] = c;
+ es[k] = c;
k = child;
}
- queue[k] = key;
+ es[k] = key;
}
- @SuppressWarnings("unchecked")
- private void siftDownUsingComparator(int k, E x) {
- int half = size >>> 1;
+ private static void siftDownUsingComparator(
+ int k, T x, Object[] es, int n, Comparator super T> cmp) {
+ // assert n > 0;
+ int half = n >>> 1;
while (k < half) {
int child = (k << 1) + 1;
- Object c = queue[child];
+ Object c = es[child];
int right = child + 1;
- if (right < size &&
- comparator.compare((E) c, (E) queue[right]) > 0)
- c = queue[child = right];
- if (comparator.compare(x, (E) c) <= 0)
+ if (right < n && cmp.compare((T) c, (T) es[right]) > 0)
+ c = es[child = right];
+ if (cmp.compare(x, (T) c) <= 0)
break;
- queue[k] = c;
+ es[k] = c;
k = child;
}
- queue[k] = x;
+ es[k] = x;
}
/**
* Establishes the heap invariant (described above) in the entire tree,
* assuming nothing about the order of the elements prior to the call.
+ * This classic algorithm due to Floyd (1964) is known to be O(size).
*/
- @SuppressWarnings("unchecked")
private void heapify() {
- for (int i = (size >>> 1) - 1; i >= 0; i--)
- siftDown(i, (E) queue[i]);
+ final Object[] es = queue;
+ int n = size, i = (n >>> 1) - 1;
+ final Comparator super E> cmp;
+ if ((cmp = comparator) == null)
+ for (; i >= 0; i--)
+ siftDownComparable(i, (E) es[i], es, n);
+ else
+ for (; i >= 0; i--)
+ siftDownUsingComparator(i, (E) es[i], es, n, cmp);
}
/**
@@ -740,10 +766,11 @@ public class PriorityQueue extends Ab
/**
* Saves this queue to a stream (that is, serializes it).
*
+ * @param s the stream
+ * @throws java.io.IOException if an I/O error occurs
* @serialData The length of the array backing the instance is
* emitted (int), followed by all of its elements
* (each an {@code Object}) in the proper order.
- * @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
@@ -754,8 +781,9 @@ public class PriorityQueue extends Ab
s.writeInt(Math.max(2, size + 1));
// Write out all elements in the "proper order".
- for (int i = 0; i < size; i++)
- s.writeObject(queue[i]);
+ final Object[] es = queue;
+ for (int i = 0, n = size; i < n; i++)
+ s.writeObject(es[i]);
}
/**
@@ -763,6 +791,9 @@ public class PriorityQueue extends Ab
* (that is, deserializes it).
*
* @param s the stream
+ * @throws ClassNotFoundException if the class of a serialized object
+ * could not be found
+ * @throws java.io.IOException if an I/O error occurs
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
@@ -772,43 +803,43 @@ public class PriorityQueue extends Ab
// Read in (and discard) array length
s.readInt();
- queue = new Object[size];
+ SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Object[].class, size);
+ final Object[] es = queue = new Object[Math.max(size, 1)];
// Read in all elements.
- for (int i = 0; i < size; i++)
- queue[i] = s.readObject();
+ for (int i = 0, n = size; i < n; i++)
+ es[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
- final Spliterator spliterator() {
- return new PriorityQueueSpliterator(this, 0, -1, 0);
- }
-
- public Stream stream() {
- return Streams.stream(spliterator());
- }
-
- public Stream parallelStream() {
- return Streams.parallelStream(spliterator());
+ /**
+ * Creates a late-binding
+ * and fail-fast {@link Spliterator} over the elements in this
+ * queue. The spliterator does not traverse elements in any particular order
+ * (the {@link Spliterator#ORDERED ORDERED} characteristic is not reported).
+ *
+ * The {@code Spliterator} reports {@link Spliterator#SIZED},
+ * {@link Spliterator#SUBSIZED}, and {@link Spliterator#NONNULL}.
+ * Overriding implementations should document the reporting of additional
+ * characteristic values.
+ *
+ * @return a {@code Spliterator} over the elements in this queue
+ * @since 1.8
+ */
+ public final Spliterator spliterator() {
+ return new PriorityQueueSpliterator(0, -1, 0);
}
- static final class PriorityQueueSpliterator implements Spliterator {
- /*
- * This is very similar to ArrayList Spliterator, except for
- * extra null checks.
- */
- private final PriorityQueue pq;
+ final class PriorityQueueSpliterator implements Spliterator {
private int index; // current index, modified on advance/split
private int fence; // -1 until first use
private int expectedModCount; // initialized when fence set
- /** Creates new spliterator covering the given range */
- PriorityQueueSpliterator(PriorityQueue pq, int origin, int fence,
- int expectedModCount) {
- this.pq = pq;
+ /** Creates new spliterator covering the given range. */
+ PriorityQueueSpliterator(int origin, int fence, int expectedModCount) {
this.index = origin;
this.fence = fence;
this.expectedModCount = expectedModCount;
@@ -817,70 +848,140 @@ public class PriorityQueue extends Ab
private int getFence() { // initialize fence to size on first use
int hi;
if ((hi = fence) < 0) {
- expectedModCount = pq.modCount;
- hi = fence = pq.size;
+ expectedModCount = modCount;
+ hi = fence = size;
}
return hi;
}
- public PriorityQueueSpliterator trySplit() {
+ public PriorityQueueSpliterator trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
return (lo >= mid) ? null :
- new PriorityQueueSpliterator(pq, lo, index = mid,
- expectedModCount);
+ new PriorityQueueSpliterator(lo, index = mid, expectedModCount);
}
- @SuppressWarnings("unchecked")
- public void forEach(Consumer super E> action) {
- int i, hi, mc; // hoist accesses and checks from loop
- PriorityQueue q; Object[] a;
+ public void forEachRemaining(Consumer super E> action) {
if (action == null)
throw new NullPointerException();
- if ((q = pq) != null && (a = q.queue) != null) {
- if ((hi = fence) < 0) {
- mc = q.modCount;
- hi = q.size;
- }
- else
- mc = expectedModCount;
- if ((i = index) >= 0 && (index = hi) <= a.length) {
- for (E e;; ++i) {
- if (i < hi) {
- if ((e = (E) a[i]) == null) // must be CME
- break;
- action.accept(e);
- }
- else if (q.modCount != mc)
- break;
- else
- return;
- }
- }
+ if (fence < 0) { fence = size; expectedModCount = modCount; }
+ final Object[] es = queue;
+ int i, hi; E e;
+ for (i = index, index = hi = fence; i < hi; i++) {
+ if ((e = (E) es[i]) == null)
+ break; // must be CME
+ action.accept(e);
}
- throw new ConcurrentModificationException();
+ if (modCount != expectedModCount)
+ throw new ConcurrentModificationException();
}
public boolean tryAdvance(Consumer super E> action) {
- int hi = getFence(), lo = index;
- if (lo >= 0 && lo < hi) {
- index = lo + 1;
- @SuppressWarnings("unchecked") E e = (E)pq.queue[lo];
- if (e == null)
+ if (action == null)
+ throw new NullPointerException();
+ if (fence < 0) { fence = size; expectedModCount = modCount; }
+ int i;
+ if ((i = index) < fence) {
+ index = i + 1;
+ E e;
+ if ((e = (E) queue[i]) == null
+ || modCount != expectedModCount)
throw new ConcurrentModificationException();
action.accept(e);
- if (pq.modCount != expectedModCount)
- throw new ConcurrentModificationException();
return true;
}
return false;
}
public long estimateSize() {
- return (long) (getFence() - index);
+ return getFence() - index;
}
public int characteristics() {
return Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.NONNULL;
}
}
+
+ /**
+ * @throws NullPointerException {@inheritDoc}
+ */
+ public boolean removeIf(Predicate super E> filter) {
+ Objects.requireNonNull(filter);
+ return bulkRemove(filter);
+ }
+
+ /**
+ * @throws NullPointerException {@inheritDoc}
+ */
+ public boolean removeAll(Collection> c) {
+ Objects.requireNonNull(c);
+ return bulkRemove(e -> c.contains(e));
+ }
+
+ /**
+ * @throws NullPointerException {@inheritDoc}
+ */
+ public boolean retainAll(Collection> c) {
+ Objects.requireNonNull(c);
+ return bulkRemove(e -> !c.contains(e));
+ }
+
+ // A tiny bit set implementation
+
+ private static long[] nBits(int n) {
+ return new long[((n - 1) >> 6) + 1];
+ }
+ private static void setBit(long[] bits, int i) {
+ bits[i >> 6] |= 1L << i;
+ }
+ private static boolean isClear(long[] bits, int i) {
+ return (bits[i >> 6] & (1L << i)) == 0;
+ }
+
+ /** Implementation of bulk remove methods. */
+ private boolean bulkRemove(Predicate super E> filter) {
+ final int expectedModCount = ++modCount;
+ final Object[] es = queue;
+ final int end = size;
+ int i;
+ // Optimize for initial run of survivors
+ for (i = 0; i < end && !filter.test((E) es[i]); i++)
+ ;
+ if (i >= end) {
+ if (modCount != expectedModCount)
+ throw new ConcurrentModificationException();
+ return false;
+ }
+ // 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.
+ final int beg = i;
+ final long[] deathRow = nBits(end - beg);
+ deathRow[0] = 1L; // set bit 0
+ for (i = beg + 1; i < end; i++)
+ if (filter.test((E) es[i]))
+ setBit(deathRow, i - beg);
+ if (modCount != expectedModCount)
+ throw new ConcurrentModificationException();
+ int w = beg;
+ for (i = beg; i < end; i++)
+ if (isClear(deathRow, i - beg))
+ es[w++] = es[i];
+ for (i = size = w; i < end; i++)
+ es[i] = null;
+ heapify();
+ return true;
+ }
+
+ /**
+ * @throws NullPointerException {@inheritDoc}
+ */
+ public void forEach(Consumer super E> action) {
+ Objects.requireNonNull(action);
+ final int expectedModCount = modCount;
+ final Object[] es = queue;
+ for (int i = 0, n = size; i < n; i++)
+ action.accept((E) es[i]);
+ if (expectedModCount != modCount)
+ throw new ConcurrentModificationException();
+ }
}