70 * remove multiple elements at an arbitrary point in the list.<p>
71 *
72 * Note: While it is permissible for lists to contain themselves as elements,
73 * extreme caution is advised: the {@code equals} and {@code hashCode}
74 * methods are no longer well defined on such a list.
75 *
76 * <p>Some list implementations have restrictions on the elements that
77 * they may contain. For example, some implementations prohibit null elements,
78 * and some have restrictions on the types of their elements. Attempting to
79 * add an ineligible element throws an unchecked exception, typically
80 * {@code NullPointerException} or {@code ClassCastException}. Attempting
81 * to query the presence of an ineligible element may throw an exception,
82 * or it may simply return false; some implementations will exhibit the former
83 * behavior and some will exhibit the latter. More generally, attempting an
84 * operation on an ineligible element whose completion would not result in
85 * the insertion of an ineligible element into the list may throw an
86 * exception or it may succeed, at the option of the implementation.
87 * Such exceptions are marked as "optional" in the specification for this
88 * interface.
89 *
90 * <h2><a id="immutable">Immutable List Static Factory Methods</a></h2>
91 * <p>The {@link List#of(Object...) List.of()} static factory methods
92 * provide a convenient way to create immutable lists. The {@code List}
93 * instances created by these methods have the following characteristics:
94 *
95 * <ul>
96 * <li>They are <em>structurally immutable</em>. Elements cannot be added, removed,
97 * or replaced. Calling any mutator method will always cause
98 * {@code UnsupportedOperationException} to be thrown.
99 * However, if the contained elements are themselves mutable,
100 * this may cause the List's contents to appear to change.
101 * <li>They disallow {@code null} elements. Attempts to create them with
102 * {@code null} elements result in {@code NullPointerException}.
103 * <li>They are serializable if all elements are serializable.
104 * <li>The order of elements in the list is the same as the order of the
105 * provided arguments, or of the elements in the provided array.
106 * <li>They are <a href="../lang/doc-files/ValueBased.html">value-based</a>.
107 * Callers should make no assumptions about the identity of the returned instances.
108 * Factories are free to create new instances or reuse existing ones. Therefore,
109 * identity-sensitive operations on these instances (reference equality ({@code ==}),
110 * identity hash code, and synchronization) are unreliable and should be avoided.
111 * <li>They are serialized as specified on the
112 * <a href="{@docRoot}/serialized-form.html#java.util.CollSer">Serialized Form</a>
113 * page.
114 * </ul>
115 *
116 * <p>This interface is a member of the
117 * <a href="{@docRoot}/java/util/package-summary.html#CollectionsFramework">
118 * Java Collections Framework</a>.
760 * <em>fail-fast</em> of the list's iterator.
761 * </ul>
762 *
763 * @implNote
764 * The created {@code Spliterator} additionally reports
765 * {@link Spliterator#SUBSIZED}.
766 *
767 * @return a {@code Spliterator} over the elements in this list
768 * @since 1.8
769 */
770 @Override
771 default Spliterator<E> spliterator() {
772 if (this instanceof RandomAccess) {
773 return new AbstractList.RandomAccessSpliterator<>(this);
774 } else {
775 return Spliterators.spliterator(this, Spliterator.ORDERED);
776 }
777 }
778
779 /**
780 * Returns an immutable list containing zero elements.
781 *
782 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
783 *
784 * @param <E> the {@code List}'s element type
785 * @return an empty {@code List}
786 *
787 * @since 9
788 */
789 static <E> List<E> of() {
790 return ImmutableCollections.List0.instance();
791 }
792
793 /**
794 * Returns an immutable list containing one element.
795 *
796 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
797 *
798 * @param <E> the {@code List}'s element type
799 * @param e1 the single element
800 * @return a {@code List} containing the specified element
801 * @throws NullPointerException if the element is {@code null}
802 *
803 * @since 9
804 */
805 static <E> List<E> of(E e1) {
806 return new ImmutableCollections.List1<>(e1);
807 }
808
809 /**
810 * Returns an immutable list containing two elements.
811 *
812 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
813 *
814 * @param <E> the {@code List}'s element type
815 * @param e1 the first element
816 * @param e2 the second element
817 * @return a {@code List} containing the specified elements
818 * @throws NullPointerException if an element is {@code null}
819 *
820 * @since 9
821 */
822 static <E> List<E> of(E e1, E e2) {
823 return new ImmutableCollections.List2<>(e1, e2);
824 }
825
826 /**
827 * Returns an immutable list containing three elements.
828 *
829 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
830 *
831 * @param <E> the {@code List}'s element type
832 * @param e1 the first element
833 * @param e2 the second element
834 * @param e3 the third element
835 * @return a {@code List} containing the specified elements
836 * @throws NullPointerException if an element is {@code null}
837 *
838 * @since 9
839 */
840 static <E> List<E> of(E e1, E e2, E e3) {
841 return new ImmutableCollections.ListN<>(e1, e2, e3);
842 }
843
844 /**
845 * Returns an immutable list containing four elements.
846 *
847 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
848 *
849 * @param <E> the {@code List}'s element type
850 * @param e1 the first element
851 * @param e2 the second element
852 * @param e3 the third element
853 * @param e4 the fourth element
854 * @return a {@code List} containing the specified elements
855 * @throws NullPointerException if an element is {@code null}
856 *
857 * @since 9
858 */
859 static <E> List<E> of(E e1, E e2, E e3, E e4) {
860 return new ImmutableCollections.ListN<>(e1, e2, e3, e4);
861 }
862
863 /**
864 * Returns an immutable list containing five elements.
865 *
866 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
867 *
868 * @param <E> the {@code List}'s element type
869 * @param e1 the first element
870 * @param e2 the second element
871 * @param e3 the third element
872 * @param e4 the fourth element
873 * @param e5 the fifth element
874 * @return a {@code List} containing the specified elements
875 * @throws NullPointerException if an element is {@code null}
876 *
877 * @since 9
878 */
879 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
880 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
881 }
882
883 /**
884 * Returns an immutable list containing six elements.
885 *
886 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
887 *
888 * @param <E> the {@code List}'s element type
889 * @param e1 the first element
890 * @param e2 the second element
891 * @param e3 the third element
892 * @param e4 the fourth element
893 * @param e5 the fifth element
894 * @param e6 the sixth element
895 * @return a {@code List} containing the specified elements
896 * @throws NullPointerException if an element is {@code null}
897 *
898 * @since 9
899 */
900 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
901 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
902 e6);
903 }
904
905 /**
906 * Returns an immutable list containing seven elements.
907 *
908 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
909 *
910 * @param <E> the {@code List}'s element type
911 * @param e1 the first element
912 * @param e2 the second element
913 * @param e3 the third element
914 * @param e4 the fourth element
915 * @param e5 the fifth element
916 * @param e6 the sixth element
917 * @param e7 the seventh element
918 * @return a {@code List} containing the specified elements
919 * @throws NullPointerException if an element is {@code null}
920 *
921 * @since 9
922 */
923 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
924 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
925 e6, e7);
926 }
927
928 /**
929 * Returns an immutable list containing eight elements.
930 *
931 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
932 *
933 * @param <E> the {@code List}'s element type
934 * @param e1 the first element
935 * @param e2 the second element
936 * @param e3 the third element
937 * @param e4 the fourth element
938 * @param e5 the fifth element
939 * @param e6 the sixth element
940 * @param e7 the seventh element
941 * @param e8 the eighth element
942 * @return a {@code List} containing the specified elements
943 * @throws NullPointerException if an element is {@code null}
944 *
945 * @since 9
946 */
947 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
948 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
949 e6, e7, e8);
950 }
951
952 /**
953 * Returns an immutable list containing nine elements.
954 *
955 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
956 *
957 * @param <E> the {@code List}'s element type
958 * @param e1 the first element
959 * @param e2 the second element
960 * @param e3 the third element
961 * @param e4 the fourth element
962 * @param e5 the fifth element
963 * @param e6 the sixth element
964 * @param e7 the seventh element
965 * @param e8 the eighth element
966 * @param e9 the ninth element
967 * @return a {@code List} containing the specified elements
968 * @throws NullPointerException if an element is {@code null}
969 *
970 * @since 9
971 */
972 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
973 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
974 e6, e7, e8, e9);
975 }
976
977 /**
978 * Returns an immutable list containing ten elements.
979 *
980 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
981 *
982 * @param <E> the {@code List}'s element type
983 * @param e1 the first element
984 * @param e2 the second element
985 * @param e3 the third element
986 * @param e4 the fourth element
987 * @param e5 the fifth element
988 * @param e6 the sixth element
989 * @param e7 the seventh element
990 * @param e8 the eighth element
991 * @param e9 the ninth element
992 * @param e10 the tenth element
993 * @return a {@code List} containing the specified elements
994 * @throws NullPointerException if an element is {@code null}
995 *
996 * @since 9
997 */
998 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) {
999 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
1000 e6, e7, e8, e9, e10);
1001 }
1002
1003 /**
1004 * Returns an immutable list containing an arbitrary number of elements.
1005 * See <a href="#immutable">Immutable List Static Factory Methods</a> for details.
1006 *
1007 * @apiNote
1008 * This method also accepts a single array as an argument. The element type of
1009 * the resulting list will be the component type of the array, and the size of
1010 * the list will be equal to the length of the array. To create a list with
1011 * a single element that is an array, do the following:
1012 *
1013 * <pre>{@code
1014 * String[] array = ... ;
1015 * List<String[]> list = List.<String[]>of(array);
1016 * }</pre>
1017 *
1018 * This will cause the {@link List#of(Object) List.of(E)} method
1019 * to be invoked instead.
1020 *
1021 * @param <E> the {@code List}'s element type
1022 * @param elements the elements to be contained in the list
1023 * @return a {@code List} containing the specified elements
1024 * @throws NullPointerException if an element is {@code null} or if the array is {@code null}
1025 *
1026 * @since 9
1027 */
1028 @SafeVarargs
1029 @SuppressWarnings("varargs")
1030 static <E> List<E> of(E... elements) {
1031 switch (elements.length) { // implicit null check of elements
1032 case 0:
1033 return ImmutableCollections.List0.instance();
1034 case 1:
1035 return new ImmutableCollections.List1<>(elements[0]);
1036 case 2:
1037 return new ImmutableCollections.List2<>(elements[0], elements[1]);
1038 default:
1039 return new ImmutableCollections.ListN<>(elements);
1040 }
1041 }
1042 }
|
70 * remove multiple elements at an arbitrary point in the list.<p>
71 *
72 * Note: While it is permissible for lists to contain themselves as elements,
73 * extreme caution is advised: the {@code equals} and {@code hashCode}
74 * methods are no longer well defined on such a list.
75 *
76 * <p>Some list implementations have restrictions on the elements that
77 * they may contain. For example, some implementations prohibit null elements,
78 * and some have restrictions on the types of their elements. Attempting to
79 * add an ineligible element throws an unchecked exception, typically
80 * {@code NullPointerException} or {@code ClassCastException}. Attempting
81 * to query the presence of an ineligible element may throw an exception,
82 * or it may simply return false; some implementations will exhibit the former
83 * behavior and some will exhibit the latter. More generally, attempting an
84 * operation on an ineligible element whose completion would not result in
85 * the insertion of an ineligible element into the list may throw an
86 * exception or it may succeed, at the option of the implementation.
87 * Such exceptions are marked as "optional" in the specification for this
88 * interface.
89 *
90 * <h2><a id="unmodifiable">Unmodifiable Lists</a></h2>
91 * <p>The {@link List#of(Object...) List.of} and
92 * {@link List#copyOf List.copyOf} static factory methods
93 * provide a convenient way to create unmodifiable lists. The {@code List}
94 * instances created by these methods have the following characteristics:
95 *
96 * <ul>
97 * <li>They are <a href="Collection.html#unmodifiable"><i>unmodifiable</i></a>. Elements cannot
98 * be added, removed, or replaced. Calling any mutator method on the List
99 * will always cause {@code UnsupportedOperationException} to be thrown.
100 * However, if the contained elements are themselves mutable,
101 * this may cause the List's contents to appear to change.
102 * <li>They disallow {@code null} elements. Attempts to create them with
103 * {@code null} elements result in {@code NullPointerException}.
104 * <li>They are serializable if all elements are serializable.
105 * <li>The order of elements in the list is the same as the order of the
106 * provided arguments, or of the elements in the provided array.
107 * <li>They are <a href="../lang/doc-files/ValueBased.html">value-based</a>.
108 * Callers should make no assumptions about the identity of the returned instances.
109 * Factories are free to create new instances or reuse existing ones. Therefore,
110 * identity-sensitive operations on these instances (reference equality ({@code ==}),
111 * identity hash code, and synchronization) are unreliable and should be avoided.
112 * <li>They are serialized as specified on the
113 * <a href="{@docRoot}/serialized-form.html#java.util.CollSer">Serialized Form</a>
114 * page.
115 * </ul>
116 *
117 * <p>This interface is a member of the
118 * <a href="{@docRoot}/java/util/package-summary.html#CollectionsFramework">
119 * Java Collections Framework</a>.
761 * <em>fail-fast</em> of the list's iterator.
762 * </ul>
763 *
764 * @implNote
765 * The created {@code Spliterator} additionally reports
766 * {@link Spliterator#SUBSIZED}.
767 *
768 * @return a {@code Spliterator} over the elements in this list
769 * @since 1.8
770 */
771 @Override
772 default Spliterator<E> spliterator() {
773 if (this instanceof RandomAccess) {
774 return new AbstractList.RandomAccessSpliterator<>(this);
775 } else {
776 return Spliterators.spliterator(this, Spliterator.ORDERED);
777 }
778 }
779
780 /**
781 * Returns an unmodifiable list containing zero elements.
782 *
783 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
784 *
785 * @param <E> the {@code List}'s element type
786 * @return an empty {@code List}
787 *
788 * @since 9
789 */
790 static <E> List<E> of() {
791 return ImmutableCollections.List0.instance();
792 }
793
794 /**
795 * Returns an unmodifiable list containing one element.
796 *
797 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
798 *
799 * @param <E> the {@code List}'s element type
800 * @param e1 the single element
801 * @return a {@code List} containing the specified element
802 * @throws NullPointerException if the element is {@code null}
803 *
804 * @since 9
805 */
806 static <E> List<E> of(E e1) {
807 return new ImmutableCollections.List1<>(e1);
808 }
809
810 /**
811 * Returns an unmodifiable list containing two elements.
812 *
813 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
814 *
815 * @param <E> the {@code List}'s element type
816 * @param e1 the first element
817 * @param e2 the second element
818 * @return a {@code List} containing the specified elements
819 * @throws NullPointerException if an element is {@code null}
820 *
821 * @since 9
822 */
823 static <E> List<E> of(E e1, E e2) {
824 return new ImmutableCollections.List2<>(e1, e2);
825 }
826
827 /**
828 * Returns an unmodifiable list containing three elements.
829 *
830 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
831 *
832 * @param <E> the {@code List}'s element type
833 * @param e1 the first element
834 * @param e2 the second element
835 * @param e3 the third element
836 * @return a {@code List} containing the specified elements
837 * @throws NullPointerException if an element is {@code null}
838 *
839 * @since 9
840 */
841 static <E> List<E> of(E e1, E e2, E e3) {
842 return new ImmutableCollections.ListN<>(e1, e2, e3);
843 }
844
845 /**
846 * Returns an unmodifiable list containing four elements.
847 *
848 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
849 *
850 * @param <E> the {@code List}'s element type
851 * @param e1 the first element
852 * @param e2 the second element
853 * @param e3 the third element
854 * @param e4 the fourth element
855 * @return a {@code List} containing the specified elements
856 * @throws NullPointerException if an element is {@code null}
857 *
858 * @since 9
859 */
860 static <E> List<E> of(E e1, E e2, E e3, E e4) {
861 return new ImmutableCollections.ListN<>(e1, e2, e3, e4);
862 }
863
864 /**
865 * Returns an unmodifiable list containing five elements.
866 *
867 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
868 *
869 * @param <E> the {@code List}'s element type
870 * @param e1 the first element
871 * @param e2 the second element
872 * @param e3 the third element
873 * @param e4 the fourth element
874 * @param e5 the fifth element
875 * @return a {@code List} containing the specified elements
876 * @throws NullPointerException if an element is {@code null}
877 *
878 * @since 9
879 */
880 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
881 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
882 }
883
884 /**
885 * Returns an unmodifiable list containing six elements.
886 *
887 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
888 *
889 * @param <E> the {@code List}'s element type
890 * @param e1 the first element
891 * @param e2 the second element
892 * @param e3 the third element
893 * @param e4 the fourth element
894 * @param e5 the fifth element
895 * @param e6 the sixth element
896 * @return a {@code List} containing the specified elements
897 * @throws NullPointerException if an element is {@code null}
898 *
899 * @since 9
900 */
901 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
902 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
903 e6);
904 }
905
906 /**
907 * Returns an unmodifiable list containing seven elements.
908 *
909 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
910 *
911 * @param <E> the {@code List}'s element type
912 * @param e1 the first element
913 * @param e2 the second element
914 * @param e3 the third element
915 * @param e4 the fourth element
916 * @param e5 the fifth element
917 * @param e6 the sixth element
918 * @param e7 the seventh element
919 * @return a {@code List} containing the specified elements
920 * @throws NullPointerException if an element is {@code null}
921 *
922 * @since 9
923 */
924 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
925 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
926 e6, e7);
927 }
928
929 /**
930 * Returns an unmodifiable list containing eight elements.
931 *
932 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
933 *
934 * @param <E> the {@code List}'s element type
935 * @param e1 the first element
936 * @param e2 the second element
937 * @param e3 the third element
938 * @param e4 the fourth element
939 * @param e5 the fifth element
940 * @param e6 the sixth element
941 * @param e7 the seventh element
942 * @param e8 the eighth element
943 * @return a {@code List} containing the specified elements
944 * @throws NullPointerException if an element is {@code null}
945 *
946 * @since 9
947 */
948 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
949 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
950 e6, e7, e8);
951 }
952
953 /**
954 * Returns an unmodifiable list containing nine elements.
955 *
956 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
957 *
958 * @param <E> the {@code List}'s element type
959 * @param e1 the first element
960 * @param e2 the second element
961 * @param e3 the third element
962 * @param e4 the fourth element
963 * @param e5 the fifth element
964 * @param e6 the sixth element
965 * @param e7 the seventh element
966 * @param e8 the eighth element
967 * @param e9 the ninth element
968 * @return a {@code List} containing the specified elements
969 * @throws NullPointerException if an element is {@code null}
970 *
971 * @since 9
972 */
973 static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
974 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
975 e6, e7, e8, e9);
976 }
977
978 /**
979 * Returns an unmodifiable list containing ten elements.
980 *
981 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
982 *
983 * @param <E> the {@code List}'s element type
984 * @param e1 the first element
985 * @param e2 the second element
986 * @param e3 the third element
987 * @param e4 the fourth element
988 * @param e5 the fifth element
989 * @param e6 the sixth element
990 * @param e7 the seventh element
991 * @param e8 the eighth element
992 * @param e9 the ninth element
993 * @param e10 the tenth element
994 * @return a {@code List} containing the specified elements
995 * @throws NullPointerException if an element is {@code null}
996 *
997 * @since 9
998 */
999 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) {
1000 return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
1001 e6, e7, e8, e9, e10);
1002 }
1003
1004 /**
1005 * Returns an unmodifiable list containing an arbitrary number of elements.
1006 * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
1007 *
1008 * @apiNote
1009 * This method also accepts a single array as an argument. The element type of
1010 * the resulting list will be the component type of the array, and the size of
1011 * the list will be equal to the length of the array. To create a list with
1012 * a single element that is an array, do the following:
1013 *
1014 * <pre>{@code
1015 * String[] array = ... ;
1016 * List<String[]> list = List.<String[]>of(array);
1017 * }</pre>
1018 *
1019 * This will cause the {@link List#of(Object) List.of(E)} method
1020 * to be invoked instead.
1021 *
1022 * @param <E> the {@code List}'s element type
1023 * @param elements the elements to be contained in the list
1024 * @return a {@code List} containing the specified elements
1025 * @throws NullPointerException if an element is {@code null} or if the array is {@code null}
1026 *
1027 * @since 9
1028 */
1029 @SafeVarargs
1030 @SuppressWarnings("varargs")
1031 static <E> List<E> of(E... elements) {
1032 switch (elements.length) { // implicit null check of elements
1033 case 0:
1034 return ImmutableCollections.List0.instance();
1035 case 1:
1036 return new ImmutableCollections.List1<>(elements[0]);
1037 case 2:
1038 return new ImmutableCollections.List2<>(elements[0], elements[1]);
1039 default:
1040 return new ImmutableCollections.ListN<>(elements);
1041 }
1042 }
1043
1044 /**
1045 * Returns an <a href="#unmodifiable">unmodifiable List</a> containing the elements of
1046 * the given Collection, in its iteration order. The given Collection must not be null,
1047 * and it must not contain any null elements. If the given Collection is subsequently
1048 * modified, the returned List will not reflect such modifications.
1049 *
1050 * @implNote
1051 * If the given Collection is an <a href="#unmodifiable">unmodifiable List</a>,
1052 * calling copyOf will generally not create a copy.
1053 *
1054 * @param <E> the {@code List}'s element type
1055 * @param coll a {@code Collection} from which elements are drawn, must be non-null
1056 * @return a {@code List} containing the elements of the given {@code Collection}
1057 * @throws NullPointerException if coll is null, or if it contains any nulls
1058 * @since 10
1059 */
1060 @SuppressWarnings("unchecked")
1061 static <E> List<E> copyOf(Collection<? extends E> coll) {
1062 if (coll instanceof ImmutableCollections.AbstractImmutableList) {
1063 return (List<E>)coll;
1064 } else {
1065 return (List<E>)List.of(coll.toArray());
1066 }
1067 }
1068 }
|