--- jsr166/src/main/java/util/PriorityQueue.java 2011/07/13 11:27:28 1.74
+++ jsr166/src/main/java/util/PriorityQueue.java 2013/01/19 18:11:56 1.84
@@ -1,12 +1,12 @@
/*
- * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2012, 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
* under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Sun designates this
+ * published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
+ * by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
@@ -24,6 +24,10 @@
*/
package java.util;
+import java.util.stream.Stream;
+import java.util.Spliterator;
+import java.util.stream.Streams;
+import java.util.function.Block;
/**
* An unbounded priority {@linkplain Queue queue} based on a priority heap.
@@ -56,7 +60,7 @@ package java.util;
* the priority queue in any particular order. If you need ordered
* traversal, consider using {@code Arrays.sort(pq.toArray())}.
*
- *
Note that this implementation is not synchronized.
+ *
Note that this implementation is not synchronized.
* Multiple threads should not access a {@code PriorityQueue}
* instance concurrently if any of the threads modifies the queue.
* Instead, use the thread-safe {@link
@@ -92,7 +96,7 @@ public class PriorityQueue extends Ab
* heap and each descendant d of n, n <= d. The element with the
* lowest value is in queue[0], assuming the queue is nonempty.
*/
- private transient Object[] queue;
+ transient Object[] queue; // non-private to simplify nested class access
/**
* The number of elements in the priority queue.
@@ -109,7 +113,7 @@ public class PriorityQueue extends Ab
* The number of times this priority queue has been
* structurally modified. See AbstractList for gory details.
*/
- private transient int modCount = 0;
+ transient int modCount = 0; // non-private to simplify nested class access
/**
* Creates a {@code PriorityQueue} with the default initial
@@ -330,6 +334,7 @@ public class PriorityQueue extends Ab
return true;
}
+ @SuppressWarnings("unchecked")
public E peek() {
return (size == 0) ? null : (E) queue[0];
}
@@ -428,14 +433,14 @@ public class PriorityQueue extends Ab
* precise control over the runtime type of the output array, and may,
* under certain circumstances, be used to save allocation costs.
*
- * Suppose x is a queue known to contain only strings.
+ *
Suppose {@code x} is a queue known to contain only strings.
* The following code can be used to dump the queue into a newly
- * allocated array of String:
+ * allocated array of {@code String}:
*
*
{@code String[] y = x.toArray(new String[0]);}
*
- * Note that toArray(new Object[0]) is identical in function to
- * toArray().
+ * Note that {@code toArray(new Object[0])} is identical in function to
+ * {@code toArray()}.
*
* @param a the array into which the elements of the queue are to
* be stored, if it is big enough; otherwise, a new array of the
@@ -446,6 +451,7 @@ public class PriorityQueue extends Ab
* this queue
* @throws NullPointerException if the specified array is null
*/
+ @SuppressWarnings("unchecked")
public T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
@@ -511,6 +517,7 @@ public class PriorityQueue extends Ab
(forgetMeNot != null && !forgetMeNot.isEmpty());
}
+ @SuppressWarnings("unchecked")
public E next() {
if (expectedModCount != modCount)
throw new ConcurrentModificationException();
@@ -563,6 +570,7 @@ public class PriorityQueue extends Ab
size = 0;
}
+ @SuppressWarnings("unchecked")
public E poll() {
if (size == 0)
return null;
@@ -588,6 +596,7 @@ 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) {
// assert i >= 0 && i < size;
modCount++;
@@ -626,6 +635,7 @@ public class PriorityQueue extends Ab
siftUpComparable(k, x);
}
+ @SuppressWarnings("unchecked")
private void siftUpComparable(int k, E x) {
Comparable super E> key = (Comparable super E>) x;
while (k > 0) {
@@ -639,6 +649,7 @@ public class PriorityQueue extends Ab
queue[k] = key;
}
+ @SuppressWarnings("unchecked")
private void siftUpUsingComparator(int k, E x) {
while (k > 0) {
int parent = (k - 1) >>> 1;
@@ -666,6 +677,7 @@ public class PriorityQueue extends Ab
siftDownComparable(k, x);
}
+ @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
@@ -684,6 +696,7 @@ public class PriorityQueue extends Ab
queue[k] = key;
}
+ @SuppressWarnings("unchecked")
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
@@ -705,6 +718,7 @@ public class PriorityQueue extends Ab
* Establishes the heap invariant (described above) in the entire tree,
* assuming nothing about the order of the elements prior to the call.
*/
+ @SuppressWarnings("unchecked")
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
@@ -724,8 +738,7 @@ public class PriorityQueue extends Ab
}
/**
- * Saves the state of the instance to a stream (that
- * is, serializes it).
+ * Saves this queue to a stream (that is, serializes it).
*
* @serialData The length of the array backing the instance is
* emitted (int), followed by all of its elements
@@ -733,7 +746,7 @@ public class PriorityQueue extends Ab
* @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
- throws java.io.IOException{
+ throws java.io.IOException {
// Write out element count, and any hidden stuff
s.defaultWriteObject();
@@ -769,4 +782,92 @@ public class PriorityQueue extends Ab
// spec has never explained what that might be.
heapify();
}
+
+ // wrapping constructor in method avoids transient javac problems
+ final PriorityQueueSpliterator spliterator(int origin, int fence,
+ int expectedModCount) {
+ return new PriorityQueueSpliterator(this, origin, fence,
+ expectedModCount);
+ }
+
+ public Stream stream() {
+ int flags = Streams.STREAM_IS_SIZED;
+ return Streams.stream
+ (() -> spliterator(0, size, modCount), flags);
+ }
+ public Stream parallelStream() {
+ int flags = Streams.STREAM_IS_SIZED;
+ return Streams.parallelStream
+ (() -> spliterator(0, size, modCount), flags);
+ }
+
+ /** Index-based split-by-two Spliterator */
+ static final class PriorityQueueSpliterator
+ implements Spliterator, Iterator {
+ private final PriorityQueue pq;
+ private int index; // current index, modified on advance/split
+ private final int fence; // one past last index
+ private final int expectedModCount; // for comodification checks
+
+ /** Create new spliterator covering the given range */
+ PriorityQueueSpliterator(PriorityQueue pq, int origin, int fence,
+ int expectedModCount) {
+ this.pq = pq; this.index = origin; this.fence = fence;
+ this.expectedModCount = expectedModCount;
+ }
+
+ public PriorityQueueSpliterator trySplit() {
+ int lo = index, mid = (lo + fence) >>> 1;
+ return (lo >= mid) ? null :
+ new PriorityQueueSpliterator(pq, lo, index = mid,
+ expectedModCount);
+ }
+
+ public void forEach(Block super E> block) {
+ Object[] a; int i, hi; // hoist accesses and checks from loop
+ if (block == null)
+ throw new NullPointerException();
+ if ((a = pq.queue).length >= (hi = fence) &&
+ (i = index) >= 0 && i < hi) {
+ index = hi;
+ do {
+ @SuppressWarnings("unchecked") E e = (E) a[i];
+ block.accept(e);
+ } while (++i < hi);
+ if (pq.modCount != expectedModCount)
+ throw new ConcurrentModificationException();
+ }
+ }
+
+ public boolean tryAdvance(Block super E> block) {
+ if (index >= 0 && index < fence) {
+ if (pq.modCount != expectedModCount)
+ throw new ConcurrentModificationException();
+ @SuppressWarnings("unchecked") E e =
+ (E)pq.queue[index++];
+ block.accept(e);
+ return true;
+ }
+ return false;
+ }
+
+ public long estimateSize() { return (long)(fence - index); }
+ public boolean hasExactSize() { return true; }
+ public boolean hasExactSplits() { return true; }
+
+ // Iterator support
+ public Iterator iterator() { return this; }
+ public void remove() { throw new UnsupportedOperationException(); }
+ public boolean hasNext() { return index >= 0 && index < fence; }
+
+ public E next() {
+ if (index < 0 || index >= fence)
+ throw new NoSuchElementException();
+ if (pq.modCount != expectedModCount)
+ throw new ConcurrentModificationException();
+ @SuppressWarnings("unchecked") E e =
+ (E) pq.queue[index++];
+ return e;
+ }
+ }
}