ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/PriorityQueue.java
(Generate patch)

Comparing jsr166/src/main/java/util/PriorityQueue.java (file contents):
Revision 1.90 by jsr166, Mon Feb 18 01:30:23 2013 UTC vs.
Revision 1.100 by jsr166, Fri Aug 29 21:42:37 2014 UTC

# Line 26 | Line 26
26   package java.util;
27   import java.util.function.Consumer;
28   import java.util.stream.Stream;
29 – import java.util.stream.Streams;
29  
30   /**
31   * An unbounded priority {@linkplain Queue queue} based on a priority heap.
# Line 66 | Line 65 | import java.util.stream.Streams;
65   * java.util.concurrent.PriorityBlockingQueue} class.
66   *
67   * <p>Implementation note: this implementation provides
68 < * O(log(n)) time for the enqueing and dequeing methods
68 > * O(log(n)) time for the enqueuing and dequeuing methods
69   * ({@code offer}, {@code poll}, {@code remove()} and {@code add});
70   * linear time for the {@code remove(Object)} and {@code contains(Object)}
71   * methods; and constant time for the retrieval methods
# Line 100 | Line 99 | public class PriorityQueue<E> extends Ab
99      /**
100       * The number of elements in the priority queue.
101       */
102 <    private int size = 0;
102 >    private int size;
103  
104      /**
105       * The comparator, or null if priority queue uses elements'
# Line 394 | Line 393 | public class PriorityQueue<E> extends Ab
393       * @return {@code true} if this queue contains the specified element
394       */
395      public boolean contains(Object o) {
396 <        return indexOf(o) != -1;
396 >        return indexOf(o) >= 0;
397      }
398  
399      /**
# Line 477 | Line 476 | public class PriorityQueue<E> extends Ab
476           * Index (into queue array) of element to be returned by
477           * subsequent call to next.
478           */
479 <        private int cursor = 0;
479 >        private int cursor;
480  
481          /**
482           * Index of element returned by most recent call to next,
# Line 497 | Line 496 | public class PriorityQueue<E> extends Ab
496           * We expect that most iterations, even those involving removals,
497           * will not need to store elements in this field.
498           */
499 <        private ArrayDeque<E> forgetMeNot = null;
499 >        private ArrayDeque<E> forgetMeNot;
500  
501          /**
502           * Element returned by the most recent call to next iff that
503           * element was drawn from the forgetMeNot list.
504           */
505 <        private E lastRetElt = null;
505 >        private E lastRetElt;
506  
507          /**
508           * The modCount value that the iterator believes that the backing
# Line 744 | Line 743 | public class PriorityQueue<E> extends Ab
743       *             emitted (int), followed by all of its elements
744       *             (each an {@code Object}) in the proper order.
745       * @param s the stream
746 +     * @throws java.io.IOException if an I/O error occurs
747       */
748      private void writeObject(java.io.ObjectOutputStream s)
749          throws java.io.IOException {
# Line 763 | Line 763 | public class PriorityQueue<E> extends Ab
763       * (that is, deserializes it).
764       *
765       * @param s the stream
766 +     * @throws ClassNotFoundException if the class of a serialized object
767 +     *         could not be found
768 +     * @throws java.io.IOException if an I/O error occurs
769       */
770      private void readObject(java.io.ObjectInputStream s)
771          throws java.io.IOException, ClassNotFoundException {
# Line 783 | Line 786 | public class PriorityQueue<E> extends Ab
786          heapify();
787      }
788  
789 <    final Spliterator<E> spliterator() {
789 >    public Spliterator<E> spliterator() {
790          return new PriorityQueueSpliterator<E>(this, 0, -1, 0);
791      }
792  
793 <    public Stream<E> stream() {
794 <        return Streams.stream(spliterator());
795 <    }
796 <
794 <    public Stream<E> parallelStream() {
795 <        return Streams.parallelStream(spliterator());
796 <    }
797 <
793 >    /**
794 >     * This is very similar to ArrayList Spliterator, except for extra
795 >     * null checks.
796 >     */
797      static final class PriorityQueueSpliterator<E> implements Spliterator<E> {
799 –        /*
800 –         * This is very similar to ArrayList Spliterator, except for
801 –         * extra null checks.
802 –         */
798          private final PriorityQueue<E> pq;
799          private int index;            // current index, modified on advance/split
800          private int fence;            // -1 until first use
801          private int expectedModCount; // initialized when fence set
802  
803 <        /** Create new spliterator covering the given  range */
803 >        /** Creates new spliterator covering the given range */
804          PriorityQueueSpliterator(PriorityQueue<E> pq, int origin, int fence,
805                               int expectedModCount) {
806              this.pq = pq;
# Line 823 | Line 818 | public class PriorityQueue<E> extends Ab
818              return hi;
819          }
820  
821 <        public PriorityQueueSpliterator<E> trySplit() {
821 >        public Spliterator<E> trySplit() {
822              int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
823              return (lo >= mid) ? null :
824                  new PriorityQueueSpliterator<E>(pq, lo, index = mid,
# Line 831 | Line 826 | public class PriorityQueue<E> extends Ab
826          }
827  
828          @SuppressWarnings("unchecked")
829 <        public void forEach(Consumer<? super E> action) {
829 >        public void forEachRemaining(Consumer<? super E> action) {
830              int i, hi, mc; // hoist accesses and checks from loop
831              PriorityQueue<E> q; Object[] a;
832              if (action == null)

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines