8180352: Add Stream.toList() method

Reviewed-by: psandoz

Author: Stuart Marks

src/java.base/share/classes/java/util/ImmutableCollections.java

@@ -842,7 +842,7 @@ static <E> List<E> of(E e1, E e2) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3);
     }
 
     /**
@@ -861,7 +861,7 @@ static <E> List<E> of(E e1, E e2, E e3) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3, E e4) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3, e4);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3, e4);
     }
 
     /**
@@ -881,7 +881,7 @@ static <E> List<E> of(E e1, E e2, E e3, E e4) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3, e4, e5);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3, e4, e5);
     }
 
     /**
@@ -902,8 +902,8 @@ static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3, e4, e5,
-                                                           e6);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3, e4, e5,
+                                                         e6);
     }
 
     /**
@@ -925,8 +925,8 @@ static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3, e4, e5,
-                                                           e6, e7);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3, e4, e5,
+                                                         e6, e7);
     }
 
     /**
@@ -949,8 +949,8 @@ static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3, e4, e5,
-                                                           e6, e7, e8);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3, e4, e5,
+                                                         e6, e7, e8);
     }
 
     /**
@@ -974,8 +974,8 @@ static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3, e4, e5,
-                                                           e6, e7, e8, e9);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3, e4, e5,
+                                                         e6, e7, e8, e9);
     }
 
     /**
@@ -1000,8 +1000,8 @@ static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
      * @since 9
      */
     static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
-        return ImmutableCollections.ListN.fromTrustedArray(e1, e2, e3, e4, e5,
-                                                           e6, e7, e8, e9, e10);
+        return ImmutableCollections.listFromTrustedArray(e1, e2, e3, e4, e5,
+                                                         e6, e7, e8, e9, e10);
     }
 
     /**
@@ -1042,7 +1042,7 @@ static <E> List<E> of(E... elements) {
             case 2:
                 return new ImmutableCollections.List12<>(elements[0], elements[1]);
             default:
-                return ImmutableCollections.ListN.fromArray(elements);
+                return ImmutableCollections.listFromArray(elements);
         }
     }
 

src/java.base/share/classes/java/util/List.java

@@ -26,6 +26,7 @@
 
 import java.util.Comparator;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Spliterator;
@@ -44,6 +45,7 @@
 import java.util.function.ToDoubleFunction;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
+import jdk.internal.access.SharedSecrets;
 
 /**
  * Abstract base class for an intermediate pipeline stage or pipeline source
@@ -620,6 +622,11 @@ public final Object[] toArray() {
         return toArray(Object[]::new);
     }
 
+    @Override
+    public List<P_OUT> toList() {
+        return SharedSecrets.getJavaUtilCollectionAccess().listFromTrustedArrayNullsAllowed(this.toArray());
+    }
+
     @Override
     public final boolean anyMatch(Predicate<? super P_OUT> predicate) {
         return evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.ANY));

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

@@ -1162,6 +1162,40 @@ <R> R collect(Supplier<R> supplier,
      */
     <R, A> R collect(Collector<? super T, A, R> collector);
 
+    /**
+     * Accumulates the elements of this stream into a {@code List}. The elements in
+     * the list will be in this stream's encounter order, if one exists. The returned List
+     * is unmodifiable; calls to any mutator method will always cause
+     * {@code UnsupportedOperationException} to be thrown. There are no
+     * guarantees on the implementation type or serializability of the returned List.
+     *
+     * <p>The returned instance may be <a href="../lang/doc-files/ValueBased.html">value-based</a>.
+     * Callers should make no assumptions about the identity of the returned instances.
+     * Identity-sensitive operations on these instances (reference equality ({@code ==}),
+     * identity hash code, and synchronization) are unreliable and should be avoided.
+     *
+     * <p>This is a <a href="package-summary.html#StreamOps">terminal operation</a>.
+     *
+     * @apiNote If more control over the returned object is required, use
+     * {@link Collectors#toCollection(Supplier)}.
+     *
+     * @implSpec The implementation in this interface returns a List produced as if by the following:
+     * <pre>{@code
+     * Collections.unmodifiableList(new ArrayList<>(Arrays.asList(this.toArray())))
+     * }</pre>
+     *
+     * @implNote Most instances of Stream will override this method and provide an implementation
+     * that is highly optimized compared to the implementation in this interface.
+     *
+     * @return a List containing the stream elements
+     *
+     * @since 16
+     */
+    @SuppressWarnings("unchecked")
+    default List<T> toList() {
+        return (List<T>) Collections.unmodifiableList(new ArrayList<>(Arrays.asList(this.toArray())));
+    }
+
     /**
      * Returns the minimum element of this stream according to the provided
      * {@code Comparator}.  This is a special case of a

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

@@ -29,4 +29,5 @@
 
 public interface JavaUtilCollectionAccess {
     <E> List<E> listFromTrustedArray(Object[] array);
+    <E> List<E> listFromTrustedArrayNullsAllowed(Object[] array);
 }

src/java.base/share/classes/jdk/internal/access/JavaUtilCollectionAccess.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2020, 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
@@ -229,7 +229,16 @@ public static void realMain(String[] args) {
                 List.of(1, 2, 3, 4, 5, 6, 7, 8),
                 List.of(1, 2, 3, 4, 5, 6, 7, 8, 9),
                 List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
-                List.of(integerArray))) {
+                List.of(integerArray),
+                Stream.<Integer>empty().toList(),
+                Stream.of(1).toList(),
+                Stream.of(1, 2).toList(),
+                Stream.of(1, 2, 3).toList(),
+                Stream.of(1, 2, 3, 4).toList(),
+                Stream.of((Integer)null).toList(),
+                Stream.of(1, null).toList(),
+                Stream.of(1, null, 3).toList(),
+                Stream.of(1, null, 3, 4).toList())) {
             testCollection(list);
             testImmutableList(list);
             testListMutatorsAlwaysThrow(list);
@@ -1096,6 +1105,15 @@ private static void testList(final List<Integer> l) {
             catch (UnsupportedOperationException ignored) {/* OK */}
             catch (Throwable t) { unexpected(t); }
         }
+
+        int hashCode = 1;
+        for (Integer i : l)
+            hashCode = 31 * hashCode + (i == null ? 0 : i.hashCode());
+        check(l.hashCode() == hashCode);
+
+        var t = new ArrayList<>(l);
+        check(t.equals(l));
+        check(l.equals(t));
     }
 
     private static void testCollection(Collection<Integer> c) {
@@ -1131,6 +1149,13 @@ private static void testCollection1(Collection<Integer> c) {
         if (c instanceof List)
             testList((List<Integer>)c);
 
+        if (c instanceof Set) {
+            int hashCode = 0;
+            for (Integer i : c)
+                hashCode = hashCode + (i == null ? 0 : i.hashCode());
+            check(c.hashCode() == hashCode);
+        }
+
         check(supportsRemove(c));
 
         try {
@@ -1230,6 +1255,15 @@ private static void checkFunctionalInvariants(Map<Integer,Integer> m) {
     private static void testMap(Map<Integer,Integer> m) {
         System.out.println("\n==> " + m.getClass().getName());
 
+        int hashCode = 0;
+        for (var e : m.entrySet()) {
+            int entryHash = (e.getKey() == null ? 0 : e.getKey().hashCode()) ^
+                            (e.getValue() == null ? 0 : e.getValue().hashCode());
+            check(e.hashCode() == entryHash);
+            hashCode += entryHash;
+        }
+        check(m.hashCode() == hashCode);
+
         if (m instanceof ConcurrentMap)
             testConcurrentMap((ConcurrentMap<Integer,Integer>) m);
 

test/jdk/java/util/Collection/MOAT.java

@@ -33,6 +33,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
+import java.util.stream.Stream;
 
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
@@ -359,6 +360,19 @@ public void copyOfRejectsNullElements() {
         List<Integer> list = List.copyOf(Arrays.asList(1, null, 3));
     }
 
+    @Test(expectedExceptions=NullPointerException.class)
+    public void copyOfRejectsNullElements2() {
+        List<String> list = List.copyOf(Stream.of("a", null, "c").toList());
+    }
+
+    @Test
+    public void copyOfCopiesNullAllowingList() {
+        List<String> orig = Stream.of("a", "b", "c").toList();
+        List<String> copy = List.copyOf(orig);
+
+        assertNotSame(orig, copy);
+    }
+
     @Test
     public void iteratorShouldNotBeListIterator() {
         List<Integer> list = List.of(1, 2, 3, 4, 5);

test/jdk/java/util/List/ListFactories.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2020, 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.openjdk.tests.java.util.stream;
+
+import org.testng.annotations.Test;
+
+import java.util.*;
+import java.util.stream.*;
+
+import static java.util.stream.LambdaTestHelpers.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+
+/**
+ * ToListOpTest
+ */
+@Test
+public class ToListOpTest extends OpTestCase {
+
+    public void testToList() {
+        assertCountSum(countTo(0).stream().toList(), 0, 0);
+        assertCountSum(countTo(10).stream().toList(), 10, 55);
+    }
+
+    private void checkUnmodifiable(List<Integer> list) {
+        try {
+            list.add(Integer.MIN_VALUE);
+            fail("List.add did not throw UnsupportedOperationException");
+        } catch (UnsupportedOperationException ignore) { }
+
+        if (list.size() > 0) {
+            try {
+                list.set(0, Integer.MAX_VALUE);
+                fail("List.set did not throw UnsupportedOperationException");
+            } catch (UnsupportedOperationException ignore) { }
+        }
+    }
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testOps(String name, TestData.OfRef<Integer> data) {
+        List<Integer> objects = exerciseTerminalOps(data, s -> s.toList());
+        checkUnmodifiable(objects);
+        assertFalse(objects.contains(null));
+    }
+
+    @Test(dataProvider = "withNull:StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testOpsWithNull(String name, TestData.OfRef<Integer> data) {
+        List<Integer> objects = exerciseTerminalOps(data, s -> s.toList());
+        checkUnmodifiable(objects);
+        assertTrue(objects.contains(null));
+    }
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testDefaultOps(String name, TestData.OfRef<Integer> data) {
+        List<Integer> objects = exerciseTerminalOps(data, s -> DefaultMethodStreams.delegateTo(s).toList());
+        checkUnmodifiable(objects);
+        assertFalse(objects.contains(null));
+    }
+
+    @Test(dataProvider = "withNull:StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testDefaultOpsWithNull(String name, TestData.OfRef<Integer> data) {
+        List<Integer> objects = exerciseTerminalOps(data, s -> DefaultMethodStreams.delegateTo(s).toList());
+        checkUnmodifiable(objects);
+        assertTrue(objects.contains(null));
+    }
+
+}