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.117 by jsr166, Tue Dec 20 22:37:31 2016 UTC vs.
Revision 1.123 by jsr166, Sun May 6 16:26:03 2018 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
2 > * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4   *
5   * This code is free software; you can redistribute it and/or modify it
# Line 26 | Line 26
26   package java.util;
27  
28   import java.util.function.Consumer;
29 + import jdk.internal.misc.SharedSecrets;
30  
31   /**
32   * An unbounded priority {@linkplain Queue queue} based on a priority heap.
# Line 73 | Line 74 | import java.util.function.Consumer;
74   * ({@code peek}, {@code element}, and {@code size}).
75   *
76   * <p>This class is a member of the
77 < * <a href="{@docRoot}/../technotes/guides/collections/index.html">
77 > * <a href="{@docRoot}/java/util/package-summary.html#CollectionsFramework">
78   * Java Collections Framework</a>.
79   *
80   * @since 1.5
# Line 350 | Line 351 | public class PriorityQueue<E> extends Ab
351  
352      private int indexOf(Object o) {
353          if (o != null) {
354 <            for (int i = 0; i < size; i++)
355 <                if (o.equals(queue[i]))
354 >            final Object[] es = queue;
355 >            for (int i = 0, n = size; i < n; i++)
356 >                if (o.equals(es[i]))
357                      return i;
358          }
359          return -1;
# Line 379 | Line 381 | public class PriorityQueue<E> extends Ab
381      }
382  
383      /**
384 <     * Version of remove using reference equality, not equals.
383 <     * Needed by iterator.remove.
384 >     * Identity-based version for use in Itr.remove.
385       *
386       * @param o element to be removed from this queue, if present
386 –     * @return {@code true} if removed
387       */
388 <    boolean removeEq(Object o) {
389 <        for (int i = 0; i < size; i++) {
390 <            if (o == queue[i]) {
388 >    void removeEq(Object o) {
389 >        final Object[] es = queue;
390 >        for (int i = 0, n = size; i < n; i++) {
391 >            if (o == es[i]) {
392                  removeAt(i);
393 <                return true;
393 >                break;
394              }
395          }
395 –        return false;
396      }
397  
398      /**
# Line 577 | Line 577 | public class PriorityQueue<E> extends Ab
577       */
578      public void clear() {
579          modCount++;
580 <        for (int i = 0; i < size; i++)
581 <            queue[i] = null;
580 >        final Object[] es = queue;
581 >        for (int i = 0, n = size; i < n; i++)
582 >            es[i] = null;
583          size = 0;
584      }
585  
# Line 734 | Line 735 | public class PriorityQueue<E> extends Ab
735      @SuppressWarnings("unchecked")
736      private void heapify() {
737          final Object[] es = queue;
738 <        final int half = (size >>> 1) - 1;
738 >        int i = (size >>> 1) - 1;
739          if (comparator == null)
740 <            for (int i = half; i >= 0; i--)
740 >            for (; i >= 0; i--)
741                  siftDownComparable(i, (E) es[i]);
742          else
743 <            for (int i = half; i >= 0; i--)
743 >            for (; i >= 0; i--)
744                  siftDownUsingComparator(i, (E) es[i]);
745      }
746  
# Line 774 | Line 775 | public class PriorityQueue<E> extends Ab
775          s.writeInt(Math.max(2, size + 1));
776  
777          // Write out all elements in the "proper order".
778 <        for (int i = 0; i < size; i++)
779 <            s.writeObject(queue[i]);
778 >        final Object[] es = queue;
779 >        for (int i = 0, n = size; i < n; i++)
780 >            s.writeObject(es[i]);
781      }
782  
783      /**
# Line 795 | Line 797 | public class PriorityQueue<E> extends Ab
797          // Read in (and discard) array length
798          s.readInt();
799  
800 +        SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Object[].class, size);
801          queue = new Object[size];
802  
803          // Read in all elements.
804 <        for (int i = 0; i < size; i++)
805 <            queue[i] = s.readObject();
804 >        final Object[] es = queue;
805 >        for (int i = 0, n = size; i < n; i++)
806 >            es[i] = s.readObject();
807  
808          // Elements are guaranteed to be in "proper order", but the
809          // spec has never explained what that might be.
# Line 893 | Line 897 | public class PriorityQueue<E> extends Ab
897              return Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.NONNULL;
898          }
899      }
900 +
901 +    /**
902 +     * @throws NullPointerException {@inheritDoc}
903 +     */
904 +    @SuppressWarnings("unchecked")
905 +    public void forEach(Consumer<? super E> action) {
906 +        Objects.requireNonNull(action);
907 +        final int expectedModCount = modCount;
908 +        final Object[] es = queue;
909 +        for (int i = 0, n = size; i < n; i++)
910 +            action.accept((E) es[i]);
911 +        if (expectedModCount != modCount)
912 +            throw new ConcurrentModificationException();
913 +    }
914   }

Diff Legend

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