The Trap of Stream#toList()

1
jshell> class ListUtils {
2
   ...>     static List<Integer> timesN(List<Integer> xs, int n) {
3
   ...>         return xs.stream()
4
   ...>                  .map(x -> x * n)
5
   ...>                  .collect(Collectors.toList());
6
   ...>     }
7
   ...> }
8
|  次を作成しました: クラス ListUtils

1
jshell> ListUtils.timesN(List.of(1, 2, 3), 2);
2
$1 ==> [2, 4, 6]

1
jshell> $1.add(8);
2
$2 ==> true
3

4
jshell> $1
5
$1 ==> [2, 4, 6, 8]

1
jshell> $1.getClass();
2
$3 ==> class java.util.ArrayList

1
public class Collectors {
2
    // ...
3

4
    /**
5
     * Returns a {@code Collector} that accumulates the input elements into a
6
     * new {@code List}. There are no guarantees on the type, mutability,
7
     * serializability, or thread-safety of the {@code List} returned; if more
8
     * control over the returned {@code List} is required, use {@link #toCollection(Supplier)}.
9
     *
10
     * @param <T> the type of the input elements
11
     * @return a {@code Collector} which collects all the input elements into a
12
     * {@code List}, in encounter order
13
     */
14
    public static <T>
15
    Collector<T, ?, List<T>> toList() {
16
        return new CollectorImpl<>(ArrayList::new, List::add,
17
                                   (left, right) -> { left.addAll(right); return left; },
18
                                   CH_ID);
19
    }
20

21
    // ...
22
}

1
jshell> class ListUtils {
2
   ...>     static List<Integer> timesN(List<Integer> xs, int n) {
3
   ...>         return xs.stream()
4
   ...>                  .map(x -> x * n)
5
   ...>                  .toList();
6
   ...>     }
7
   ...> }
8
|  次を作成しました: クラス ListUtils

1
jshell> ListUtils.timesN(List.of(1, 2, 3), 2);
2
$4 ==> [2, 4, 6]

1
jshell> $4.add(8);
2
|  例外java.lang.UnsupportedOperationException
3
|        at ImmutableCollections.uoe (ImmutableCollections.java:142)
4
|        at ImmutableCollections$AbstractImmutableCollection.add (ImmutableCollections.java:147)
5
|        at (#4:1)

1
jshell> $4.getClass();
2
$5 ==> class java.util.ImmutableCollections$ListN

1
    /**
2
     * Returns an array containing the elements of this stream.
3
     *
4
     * <p>This is a <a href="package-summary.html#StreamOps">terminal
5
     * operation</a>.
6
     *
7
     * @return an array, whose {@linkplain Class#getComponentType runtime component
8
     * type} is {@code Object}, containing the elements of this stream
9
     */
10
    Object[] toArray();

1
    /**
2
     * {@inheritDoc}
3
     *
4
     * @implSpec
5
     * This implementation returns an array containing all the elements
6
     * returned by this collection's iterator, in the same order, stored in
7
     * consecutive elements of the array, starting with index {@code 0}.
8
     * The length of the returned array is equal to the number of elements
9
     * returned by the iterator, even if the size of this collection changes
10
     * during iteration, as might happen if the collection permits
11
     * concurrent modification during iteration.  The {@code size} method is
12
     * called only as an optimization hint; the correct result is returned
13
     * even if the iterator returns a different number of elements.
14
     *
15
     * <p>This method is equivalent to:
16
     *
17
     *  <pre> {@code
18
     * List<E> list = new ArrayList<E>(size());
19
     * for (E e : this)
20
     *     list.add(e);
21
     * return list.toArray();
22
     * }</pre>
23
     */
24
    public Object[] toArray() {
25
        // Estimate size of array; be prepared to see more or fewer elements
26
        Object[] r = new Object[size()];
27
        Iterator<E> it = iterator();
28
        for (int i = 0; i < r.length; i++) {
29
            if (! it.hasNext()) // fewer elements than expected
30
                return Arrays.copyOf(r, i);
31
            r[i] = it.next();
32
        }
33
        return it.hasNext() ? finishToArray(r, it) : r;
34
    }

1
    /**
2
     * Returns a fixed-size list backed by the specified array. Changes made to
3
     * the array will be visible in the returned list, and changes made to the
4
     * list will be visible in the array. The returned list is
5
     * {@link Serializable} and implements {@link RandomAccess}.
6
     *
7
     * <p>The returned list implements the optional {@code Collection} methods, except
8
     * those that would change the size of the returned list. Those methods leave
9
     * the list unchanged and throw {@link UnsupportedOperationException}.
10
     *
11
     * @apiNote
12
     * This method acts as bridge between array-based and collection-based
13
     * APIs, in combination with {@link Collection#toArray}.
14
     *
15
     * <p>This method provides a way to wrap an existing array:
16
     * <pre>{@code
17
     *     Integer[] numbers = ...
18
     *     ...
19
     *     List<Integer> values = Arrays.asList(numbers);
20
     * }</pre>
21
     *
22
     * <p>This method also provides a convenient way to create a fixed-size
23
     * list initialized to contain several elements:
24
     * <pre>{@code
25
     *     List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
26
     * }</pre>
27
     *
28
     * <p><em>The list returned by this method is modifiable.</em>
29
     * To create an unmodifiable list, use
30
     * {@link Collections#unmodifiableList Collections.unmodifiableList}
31
     * or <a href="List.html#unmodifiable">Unmodifiable Lists</a>.
32
     *
33
     * @param <T> the class of the objects in the array
34
     * @param a the array by which the list will be backed
35
     * @return a list view of the specified array
36
     * @throws NullPointerException if the specified array is {@code null}
37
     */
38
    @SafeVarargs
39
    @SuppressWarnings("varargs")
40
    public static <T> List<T> asList(T... a) {
41
        return new ArrayList<>(a);
42
    }

1
    /**
2
     * @serial include
3
     */
4
    private static class ArrayList<E> extends AbstractList<E>
5
        implements RandomAccess, java.io.Serializable
6
    {
7
        @java.io.Serial
8
        private static final long serialVersionUID = -2764017481108945198L;
9
        @SuppressWarnings("serial") // Conditionally serializable
10
        private final E[] a;
11

12
        ArrayList(E[] array) {
13
            a = Objects.requireNonNull(array);
14
        }

1
    /**
2
     * {@inheritDoc}
3
     *
4
     * @implSpec
5
     * This implementation always throws an
6
     * {@code UnsupportedOperationException}.
7
     *
8
     * @throws UnsupportedOperationException {@inheritDoc}
9
     * @throws ClassCastException            {@inheritDoc}
10
     * @throws NullPointerException          {@inheritDoc}
11
     * @throws IllegalArgumentException      {@inheritDoc}
12
     * @throws IndexOutOfBoundsException     {@inheritDoc}
13
     */
14
    public void add(int index, E element) {
15
        throw new UnsupportedOperationException();
16
    }

1
    /**
2
     * Constructs a list containing the elements of the specified
3
     * collection, in the order they are returned by the collection's
4
     * iterator.
5
     *
6
     * @param c the collection whose elements are to be placed into this list
7
     * @throws NullPointerException if the specified collection is null
8
     */
9
    public ArrayList(Collection<? extends E> c) {
10
        Object[] a = c.toArray();
11
        if ((size = a.length) != 0) {
12
            if (c.getClass() == ArrayList.class) {
13
                elementData = a;
14
            } else {
15
                elementData = Arrays.copyOf(a, size, Object[].class);
16
            }
17
        } else {
18
            // replace with empty array.
19
            elementData = EMPTY_ELEMENTDATA;
20
        }
21
    }

1
        @Override
2
        public Object[] toArray() {
3
            return Arrays.copyOf(a, a.length, Object[].class);
4
        }

1
    /**
2
     * Copies the specified array, truncating or padding with nulls (if necessary)
3
     * so the copy has the specified length.  For all indices that are
4
     * valid in both the original array and the copy, the two arrays will
5
     * contain identical values.  For any indices that are valid in the
6
     * copy but not the original, the copy will contain {@code null}.
7
     * Such indices will exist if and only if the specified length
8
     * is greater than that of the original array.
9
     * The resulting array is of the class {@code newType}.
10
     *
11
     * @param <U> the class of the objects in the original array
12
     * @param <T> the class of the objects in the returned array
13
     * @param original the array to be copied
14
     * @param newLength the length of the copy to be returned
15
     * @param newType the class of the copy to be returned
16
     * @return a copy of the original array, truncated or padded with nulls
17
     *     to obtain the specified length
18
     * @throws NegativeArraySizeException if {@code newLength} is negative
19
     * @throws NullPointerException if {@code original} is null
20
     * @throws ArrayStoreException if an element copied from
21
     *     {@code original} is not of a runtime type that can be stored in
22
     *     an array of class {@code newType}
23
     * @since 1.6
24
     */
25
    @IntrinsicCandidate
26
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
27
        @SuppressWarnings("unchecked")
28
        T[] copy = ((Object)newType == (Object)Object[].class)
29
            ? (T[]) new Object[newLength]
30
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
31
        System.arraycopy(original, 0, copy, 0,
32
                         Math.min(original.length, newLength));
33
        return copy;
34
    }

1
    /**
2
     * Returns an <a href="Collection.html#unmodview">unmodifiable view</a> of the
3
     * specified list. Query operations on the returned list "read through" to the
4
     * specified list, and attempts to modify the returned list, whether
5
     * direct or via its iterator, result in an
6
     * {@code UnsupportedOperationException}.<p>
7
     *
8
     * The returned list will be serializable if the specified list
9
     * is serializable. Similarly, the returned list will implement
10
     * {@link RandomAccess} if the specified list does.
11
     *
12
     * @implNote This method may return its argument if the argument is already unmodifiable.
13
     * @param  <T> the class of the objects in the list
14
     * @param  list the list for which an unmodifiable view is to be returned.
15
     * @return an unmodifiable view of the specified list.
16
     */
17
    @SuppressWarnings("unchecked")
18
    public static <T> List<T> unmodifiableList(List<? extends T> list) {
19
        if (list.getClass() == UnmodifiableList.class || list.getClass() == UnmodifiableRandomAccessList.class) {
20
           return (List<T>) list;
21
        }
22

23
        return (list instanceof RandomAccess ?
24
                new UnmodifiableRandomAccessList<>(list) :
25
                new UnmodifiableList<>(list));
26
    }

1
    /**
2
     * @serial include
3
     */
4
    static class UnmodifiableRandomAccessList<E> extends UnmodifiableList<E>
5
                                              implements RandomAccess
6
    {
7
        UnmodifiableRandomAccessList(List<? extends E> list) {
8
            super(list);
9
        }
10

11
        public List<E> subList(int fromIndex, int toIndex) {
12
            return new UnmodifiableRandomAccessList<>(
13
                list.subList(fromIndex, toIndex));
14
        }
15

16
        @java.io.Serial
17
        private static final long serialVersionUID = -2542308836966382001L;
18

19
        /**
20
         * Allows instances to be deserialized in pre-1.4 JREs (which do
21
         * not have UnmodifiableRandomAccessList).  UnmodifiableList has
22
         * a readResolve method that inverts this transformation upon
23
         * deserialization.
24
         */
25
        @java.io.Serial
26
        private Object writeReplace() {
27
            return new UnmodifiableList<>(list);
28
        }
29
    }

1
    /**
2
     * @serial include
3
     */
4
    static class UnmodifiableList<E> extends UnmodifiableCollection<E>
5
                                  implements List<E> {
6
        @java.io.Serial
7
        private static final long serialVersionUID = -283967356065247728L;
8

9
        @SuppressWarnings("serial") // Conditionally serializable
10
        final List<? extends E> list;
11

12
        UnmodifiableList(List<? extends E> list) {
13
            super(list);
14
            this.list = list;
15
        }
16

17
        public boolean equals(Object o) {return o == this || list.equals(o);}
18
        public int hashCode()           {return list.hashCode();}
19

20
        public E get(int index) {return list.get(index);}
21
        public E set(int index, E element) {
22
            throw new UnsupportedOperationException();
23
        }
24
        public void add(int index, E element) {
25
            throw new UnsupportedOperationException();
26
        }
27
        // ...

1
public class Collectors {
2
    // ...
3

4
    /**
5
     * Returns a {@code Collector} that accumulates the input elements into an
6
     * <a href="../List.html#unmodifiable">unmodifiable List</a> in encounter
7
     * order. The returned Collector disallows null values and will throw
8
     * {@code NullPointerException} if it is presented with a null value.
9
     *
10
     * @param <T> the type of the input elements
11
     * @return a {@code Collector} that accumulates the input elements into an
12
     * <a href="../List.html#unmodifiable">unmodifiable List</a> in encounter order
13
     * @since 10
14
     */
15
    public static <T>
16
    Collector<T, ?, List<T>> toUnmodifiableList() {
17
        return new CollectorImpl<>(ArrayList::new, List::add,
18
                                   (left, right) -> { left.addAll(right); return left; },
19
                                   list -> {
20
                                       if (list.getClass() == ArrayList.class) { // ensure it's trusted
21
                                           return SharedSecrets.getJavaUtilCollectionAccess()
22
                                                               .listFromTrustedArray(list.toArray());
23
                                       } else {
24
                                           throw new IllegalArgumentException();
25
                                       }
26
                                   },
27
                                   CH_NOID);
28
    }
29
}

1
/** A repository of "shared secrets", which are a mechanism for
2
    calling implementation-private methods in another package without
3
    using reflection. A package-private class implements a public
4
    interface and provides the ability to call package-private methods
5
    within that package; the object implementing that interface is
6
    provided through a third package to which access is restricted.
7
    This framework avoids the primary disadvantage of using reflection
8
    for this purpose, namely the loss of compile-time checking. */
9

10
public class SharedSecrets {
11
    // ...
12

13
    public static JavaUtilCollectionAccess getJavaUtilCollectionAccess() {
14
        var access = javaUtilCollectionAccess;
15
        if (access == null) {
16
            try {
17
                Class.forName("java.util.ImmutableCollections$Access", true, null);
18
                access = javaUtilCollectionAccess;
19
            } catch (ClassNotFoundException e) {}
20
        }
21
        return access;
22
    }
23

24
    // ...
25
}

1
    static class Access {
2
        static {
3
            SharedSecrets.setJavaUtilCollectionAccess(new JavaUtilCollectionAccess() {
4
                public <E> List<E> listFromTrustedArray(Object[] array) {
5
                    return ImmutableCollections.listFromTrustedArray(array);
6
                }
7
                public <E> List<E> listFromTrustedArrayNullsAllowed(Object[] array) {
8
                    return ImmutableCollections.listFromTrustedArrayNullsAllowed(array);
9
                }
10
            });
11
        }
12
    }

1
    /**
2
     * Creates a new List from a trusted array, checking for and rejecting null
3
     * elements.
4
     *
5
     * <p>A trusted array has no references retained by the caller. It can therefore be
6
     * safely reused as the List's internal storage, avoiding a defensive copy. The array's
7
     * class must be Object[].class. This method is declared with a parameter type of
8
     * Object... instead of E... so that a varargs call doesn't accidentally create an array
9
     * of some class other than Object[].class.
10
     *
11
     * @param <E> the List's element type
12
     * @param input the input array
13
     * @return the new list
14
     */
15
    @SuppressWarnings("unchecked")
16
    static <E> List<E> listFromTrustedArray(Object... input) {
17
        assert input.getClass() == Object[].class;
18
        for (Object o : input) { // implicit null check of 'input' array
19
            Objects.requireNonNull(o);
20
        }
21

22
        return switch (input.length) {
23
            case 0  -> (List<E>) ImmutableCollections.EMPTY_LIST;
24
            case 1  -> (List<E>) new List12<>(input[0]);
25
            case 2  -> (List<E>) new List12<>(input[0], input[1]);
26
            default -> (List<E>) new ListN<>(input, false);
27
        };
28
    }

1
jshell> Stream.of(1, null, 3).toList();
2
$1 ==> [1, null, 3]
3

4
jshell> Stream.of(1, null, 3).collect(Collectors.toUnmodifiableList());
5
|  例外java.lang.NullPointerException
6
|        at Objects.requireNonNull (Objects.java:209)
7
|        at ImmutableCollections.listFromTrustedArray (ImmutableCollections.java:213)
8
|        at ImmutableCollections$Access$1.listFromTrustedArray (ImmutableCollections.java:124)
9
|        at Collectors.lambda$toUnmodifiableList$6 (Collectors.java:303)
10
|        at ReferencePipeline.collect (ReferencePipeline.java:686)
11
|        at (#13:1)