8362958: Unnecessary copying / sorting in Streams using Comparator.naturalOrder()

src/java.base/share/classes/java/util/stream/SortedOps.java

@@ -108,13 +108,10 @@ private static final class OfRef<T> extends ReferencePipeline.StatefulOp<T, T> {
          * {@code Comparable}.
          */
         OfRef(AbstractPipeline<?, T, ?> upstream) {
-            super(upstream, StreamShape.REFERENCE,
-                  StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SORTED);
-            this.isNaturalSort = true;
             // Will throw CCE when we try to sort if T is not Comparable
             @SuppressWarnings("unchecked")
             Comparator<? super T> comp = (Comparator<? super T>) Comparator.naturalOrder();
-            this.comparator = comp;
+            this(upstream, comp);
         }
 
         /**
@@ -123,10 +120,13 @@ private static final class OfRef<T> extends ReferencePipeline.StatefulOp<T, T> {
          * @param comparator The comparator to be used to evaluate ordering.
          */
         OfRef(AbstractPipeline<?, T, ?> upstream, Comparator<? super T> comparator) {
+            Objects.requireNonNull(comparator);
+            boolean isNaturalSort = Comparator.naturalOrder().equals(comparator);
             super(upstream, StreamShape.REFERENCE,
-                  StreamOpFlag.IS_ORDERED | StreamOpFlag.NOT_SORTED);
-            this.isNaturalSort = false;
-            this.comparator = Objects.requireNonNull(comparator);
+                  StreamOpFlag.IS_ORDERED |
+                          (isNaturalSort ? StreamOpFlag.IS_SORTED : StreamOpFlag.NOT_SORTED));
+            this.isNaturalSort = isNaturalSort;
+            this.comparator = comparator;
         }
 
         @Override

src/java.base/share/classes/java/util/stream/StreamOpFlag.java

@@ -24,6 +24,7 @@
  */
 package java.util.stream;
 
+import java.util.Comparator;
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.Spliterator;
@@ -738,24 +739,25 @@ static int toCharacteristics(int streamFlags) {
      *
      * @implSpec
      * If the spliterator is naturally {@code SORTED} (the associated
-     * {@code Comparator} is {@code null}) then the characteristic is converted
-     * to the {@link #SORTED} flag, otherwise the characteristic is not
-     * converted.
+     * {@code Comparator} is {@code null} or {@code Comparator.naturalOrder()}) then
+     * the characteristic is converted to the {@link #SORTED} flag, otherwise
+     * the characteristic is not converted.
      *
      * @param spliterator the spliterator from which to obtain characteristic
      *        bit set.
      * @return the stream flags.
      */
     static int fromCharacteristics(Spliterator<?> spliterator) {
         int characteristics = spliterator.characteristics();
-        if ((characteristics & Spliterator.SORTED) != 0 && spliterator.getComparator() != null) {
-            // Do not propagate the SORTED characteristic if it does not correspond
-            // to a natural sort order
-            return characteristics & SPLITERATOR_CHARACTERISTICS_MASK & ~Spliterator.SORTED;
-        }
-        else {
-            return characteristics & SPLITERATOR_CHARACTERISTICS_MASK;
+        if ((characteristics & Spliterator.SORTED) != 0) {
+            Comparator<?> comparator = spliterator.getComparator();
+            if (comparator != null && !Comparator.naturalOrder().equals(comparator)) {
+                // Do not propagate the SORTED characteristic if it does not correspond
+                // to a natural sort order
+                return characteristics & SPLITERATOR_CHARACTERISTICS_MASK & ~Spliterator.SORTED;
+            }
         }
+        return characteristics & SPLITERATOR_CHARACTERISTICS_MASK;
     }
 
     /**

test/jdk/java/util/stream/boottest/java.base/java/util/stream/StreamOpFlagsTest.java

@@ -377,5 +377,10 @@ public Comparator<? super Object> getComparator() {
             int flags = StreamOpFlag.fromCharacteristics(new SortedEmptySpliterator((a, b) -> 0));
             assertEquals(flags, 0);
         }
+
+        {
+            int flags = StreamOpFlag.fromCharacteristics(new SortedEmptySpliterator(Comparator.naturalOrder()));
+            assertEquals(flags, StreamOpFlag.IS_SORTED);
+        }
     }
 }

test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java

@@ -25,6 +25,7 @@
 import org.testng.annotations.Test;
 
 import java.util.*;
+import java.util.Comparator;
 import java.util.Spliterators;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiFunction;
@@ -115,10 +116,14 @@ public void testSorted() {
 
         Collections.reverse(to10);
         assertSorted(to10.stream().sorted().iterator());
+        assertSorted(to10.stream().sorted(Comparator.naturalOrder()).iterator());
 
         Spliterator<Integer> s = to10.stream().sorted().spliterator();
         assertTrue(s.hasCharacteristics(Spliterator.SORTED));
 
+        s = to10.stream().sorted(Comparator.naturalOrder()).spliterator();
+        assertTrue(s.hasCharacteristics(Spliterator.SORTED));
+
         s = to10.stream().sorted(cInteger.reversed()).spliterator();
         assertFalse(s.hasCharacteristics(Spliterator.SORTED));
     }