8362958: Optimize Stream sorting with Comparator.naturalOrder()

Author: kilink

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

@@ -60,7 +60,8 @@ static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream) {
      */
     static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream,
                                 Comparator<? super T> comparator) {
-        return new OfRef<>(upstream, comparator);
+        return Comparator.naturalOrder().equals(comparator) ?
+                new OfRef<>(upstream) : new OfRef<>(upstream, comparator);
     }
 
     /**

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,17 +739,19 @@ 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) {
+        if ((characteristics & Spliterator.SORTED) != 0 &&
+                !(spliterator.getComparator() == null ||
+                        spliterator.getComparator().equals(Comparator.naturalOrder()))) {
             // Do not propagate the SORTED characteristic if it does not correspond
             // to a natural sort order
             return characteristics & SPLITERATOR_CHARACTERISTICS_MASK & ~Spliterator.SORTED;

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));
     }