jdk-sandbox: comparison src/java.base/share/classes/java/util/Collections.java

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 /*
-* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2019, 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.  Oracle designates this
 */
 package java.util;
 import java.io.IOException;
+import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.lang.reflect.Array;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
+import jdk.internal.access.SharedSecrets;
 /**
 * This class consists exclusively of static methods that operate on or return
 * collections.  It contains polymorphic algorithms that operate on
 * collections, "wrappers", which return a new collection backed by a
 /**
 * @serial include
 */
 static class UnmodifiableCollection<E> implements Collection<E>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 1820017752578914078L;
+@SuppressWarnings("serial") // Conditionally serializable
 final Collection<? extends E> c;
 UnmodifiableCollection(Collection<? extends E> c) {
 if (c==null)
 throw new NullPointerException();
 /**
 * @serial include
 */
 static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
 implements Set<E>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -9215047833775013803L;
 UnmodifiableSet(Set<? extends E> s)     {super(s);}
 public boolean equals(Object o) {return o == this || c.equals(o);}
 public int hashCode()           {return c.hashCode();}
 * @serial include
 */
 static class UnmodifiableSortedSet<E>
 extends UnmodifiableSet<E>
 implements SortedSet<E>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -4929149591599911165L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final SortedSet<E> ss;
 UnmodifiableSortedSet(SortedSet<E> s) {super(s); ss = s;}
 public Comparator<? super E> comparator() {return ss.comparator();}
 */
 static class UnmodifiableNavigableSet<E>
 extends UnmodifiableSortedSet<E>
 implements NavigableSet<E>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -6027448201786391929L;
 /**
 * A singleton empty unmodifiable navigable set used for
 * {@link #emptyNavigableSet()}.
 *
 * @param <E> type of elements, if there were any, and bounds
 */
 private static class EmptyNavigableSet<E> extends UnmodifiableNavigableSet<E>
 implements Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -6291252904449939134L;
 public EmptyNavigableSet() {
 super(new TreeSet<>());
 }
+@java.io.Serial
 private Object readResolve()        { return EMPTY_NAVIGABLE_SET; }
 }
 @SuppressWarnings("rawtypes")
 private static final NavigableSet<?> EMPTY_NAVIGABLE_SET =
 new EmptyNavigableSet<>();
 /**
 * The instance we are protecting.
 */
+@SuppressWarnings("serial") // Conditionally serializable
 private final NavigableSet<E> ns;
 UnmodifiableNavigableSet(NavigableSet<E> s)         {super(s); ns = s;}
 public E lower(E e)                             { return ns.lower(e); }
 /**
 * @serial include
 */
 static class UnmodifiableList<E> extends UnmodifiableCollection<E>
 implements List<E> {
+@java.io.Serial
 private static final long serialVersionUID = -283967356065247728L;
+@SuppressWarnings("serial") // Conditionally serializable
 final List<? extends E> list;
 UnmodifiableList(List<? extends E> list) {
 super(list);
 this.list = list;
 *
 * Note: Unfortunately, UnmodifiableRandomAccessList instances
 * serialized in 1.4.1 and deserialized in 1.4 will become
 * UnmodifiableList instances, as this method was missing in 1.4.
 */
+@java.io.Serial
 private Object readResolve() {
 return (list instanceof RandomAccess
 ? new UnmodifiableRandomAccessList<>(list)
 : this);
 }
 public List<E> subList(int fromIndex, int toIndex) {
 return new UnmodifiableRandomAccessList<>(
 list.subList(fromIndex, toIndex));
 }
+@java.io.Serial
 private static final long serialVersionUID = -2542308836966382001L;
 /**
 * Allows instances to be deserialized in pre-1.4 JREs (which do
 * not have UnmodifiableRandomAccessList).  UnmodifiableList has
 * a readResolve method that inverts this transformation upon
 * deserialization.
 */
+@java.io.Serial
 private Object writeReplace() {
 return new UnmodifiableList<>(list);
 }
 }
 /**
 * @serial include
 */
 private static class UnmodifiableMap<K,V> implements Map<K,V>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -1034234728574286014L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final Map<? extends K, ? extends V> m;
 UnmodifiableMap(Map<? extends K, ? extends V> m) {
 if (m==null)
 throw new NullPointerException();
 *
 * @serial include
 */
 static class UnmodifiableEntrySet<K,V>
 extends UnmodifiableSet<Map.Entry<K,V>> {
+@java.io.Serial
 private static final long serialVersionUID = 7854390611657943733L;
 @SuppressWarnings({"unchecked", "rawtypes"})
 UnmodifiableEntrySet(Set<? extends Map.Entry<? extends K, ? extends V>> s) {
 // Need to cast to raw in order to work around a limitation in the type system
 * @serial include
 */
 static class UnmodifiableSortedMap<K,V>
 extends UnmodifiableMap<K,V>
 implements SortedMap<K,V>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -8806743815996713206L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final SortedMap<K, ? extends V> sm;
 UnmodifiableSortedMap(SortedMap<K, ? extends V> m) {super(m); sm = m; }
 public Comparator<? super K> comparator()   { return sm.comparator(); }
 public SortedMap<K,V> subMap(K fromKey, K toKey)
 * @serial include
 */
 static class UnmodifiableNavigableMap<K,V>
 extends UnmodifiableSortedMap<K,V>
 implements NavigableMap<K,V>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -4858195264774772197L;
 /**
 * A class for the {@link EMPTY_NAVIGABLE_MAP} which needs readResolve
 * to preserve singleton property.
 * @param <V> type of values, if there were any
 */
 private static class EmptyNavigableMap<K,V> extends UnmodifiableNavigableMap<K,V>
 implements Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -2239321462712562324L;
 EmptyNavigableMap()                       { super(new TreeMap<>()); }
 @Override
 public NavigableSet<K> navigableKeySet()
 { return emptyNavigableSet(); }
+@java.io.Serial
 private Object readResolve()        { return EMPTY_NAVIGABLE_MAP; }
 }
 /**
 * Singleton for {@link emptyNavigableMap()} which is also immutable.
 new EmptyNavigableMap<>();
 /**
 * The instance we wrap and protect.
 */
+@SuppressWarnings("serial") // Conditionally serializable
 private final NavigableMap<K, ? extends V> nm;
 UnmodifiableNavigableMap(NavigableMap<K, ? extends V> m)
 {super(m); nm = m;}
 /**
 * @serial include
 */
 static class SynchronizedCollection<E> implements Collection<E>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 3053995032091335093L;
+@SuppressWarnings("serial") // Conditionally serializable
 final Collection<E> c;  // Backing Collection
+@SuppressWarnings("serial") // Conditionally serializable
 final Object mutex;     // Object on which to synchronize
 SynchronizedCollection(Collection<E> c) {
 this.c = Objects.requireNonNull(c);
 mutex = this;
 }
 @Override
 public Stream<E> parallelStream() {
 return c.parallelStream(); // Must be manually synched by user!
 }
+@java.io.Serial
 private void writeObject(ObjectOutputStream s) throws IOException {
 synchronized (mutex) {s.defaultWriteObject();}
 }
 }
 * @serial include
 */
 static class SynchronizedSet<E>
 extends SynchronizedCollection<E>
 implements Set<E> {
+@java.io.Serial
 private static final long serialVersionUID = 487447009682186044L;
 SynchronizedSet(Set<E> s) {
 super(s);
 }
 */
 static class SynchronizedSortedSet<E>
 extends SynchronizedSet<E>
 implements SortedSet<E>
 {
+@java.io.Serial
 private static final long serialVersionUID = 8695801310862127406L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final SortedSet<E> ss;
 SynchronizedSortedSet(SortedSet<E> s) {
 super(s);
 ss = s;
 */
 static class SynchronizedNavigableSet<E>
 extends SynchronizedSortedSet<E>
 implements NavigableSet<E>
 {
+@java.io.Serial
 private static final long serialVersionUID = -5505529816273629798L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final NavigableSet<E> ns;
 SynchronizedNavigableSet(NavigableSet<E> s) {
 super(s);
 ns = s;
 * @serial include
 */
 static class SynchronizedList<E>
 extends SynchronizedCollection<E>
 implements List<E> {
+@java.io.Serial
 private static final long serialVersionUID = -7754090372962971524L;
+@SuppressWarnings("serial") // Conditionally serializable
 final List<E> list;
 SynchronizedList(List<E> list) {
 super(list);
 this.list = list;
 *
 * Note: Unfortunately, SynchronizedRandomAccessList instances
 * serialized in 1.4.1 and deserialized in 1.4 will become
 * SynchronizedList instances, as this method was missing in 1.4.
 */
+@java.io.Serial
 private Object readResolve() {
 return (list instanceof RandomAccess
 ? new SynchronizedRandomAccessList<>(list)
 : this);
 }
 return new SynchronizedRandomAccessList<>(
 list.subList(fromIndex, toIndex), mutex);
 }
 }
+@java.io.Serial
 private static final long serialVersionUID = 1530674583602358482L;
 /**
 * Allows instances to be deserialized in pre-1.4 JREs (which do
 * not have SynchronizedRandomAccessList).  SynchronizedList has
 * a readResolve method that inverts this transformation upon
 * deserialization.
 */
+@java.io.Serial
 private Object writeReplace() {
 return new SynchronizedList<>(list);
 }
 }
 /**
 * @serial include
 */
 private static class SynchronizedMap<K,V>
 implements Map<K,V>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 1978198479659022715L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final Map<K,V> m;     // Backing Map
+@SuppressWarnings("serial") // Conditionally serializable
 final Object      mutex;        // Object on which to synchronize
 SynchronizedMap(Map<K,V> m) {
 this.m = Objects.requireNonNull(m);
 mutex = this;
 public V merge(K key, V value,
 BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
 synchronized (mutex) {return m.merge(key, value, remappingFunction);}
 }
+@java.io.Serial
 private void writeObject(ObjectOutputStream s) throws IOException {
 synchronized (mutex) {s.defaultWriteObject();}
 }
 }
 */
 static class SynchronizedSortedMap<K,V>
 extends SynchronizedMap<K,V>
 implements SortedMap<K,V>
 {
+@java.io.Serial
 private static final long serialVersionUID = -8798146769416483793L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final SortedMap<K,V> sm;
 SynchronizedSortedMap(SortedMap<K,V> m) {
 super(m);
 sm = m;
 */
 static class SynchronizedNavigableMap<K,V>
 extends SynchronizedSortedMap<K,V>
 implements NavigableMap<K,V>
 {
+@java.io.Serial
 private static final long serialVersionUID = 699392247599746807L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final NavigableMap<K,V> nm;
 SynchronizedNavigableMap(NavigableMap<K,V> m) {
 super(m);
 nm = m;
 /**
 * @serial include
 */
 static class CheckedCollection<E> implements Collection<E>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 1578914078182001775L;
+@SuppressWarnings("serial") // Conditionally serializable
 final Collection<E> c;
+@SuppressWarnings("serial") // Conditionally serializable
 final Class<E> type;
 @SuppressWarnings("unchecked")
 E typeCheck(Object o) {
 if (o != null && !type.isInstance(o))
 };
 }
 public boolean add(E e)          { return c.add(typeCheck(e)); }
+@SuppressWarnings("serial") // Conditionally serializable
 private E[] zeroLengthElementArray; // Lazily initialized
 private E[] zeroLengthElementArray() {
 return zeroLengthElementArray != null ? zeroLengthElementArray :
 (zeroLengthElementArray = zeroLengthArray(type));
 */
 static class CheckedQueue<E>
 extends CheckedCollection<E>
 implements Queue<E>, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 1433151992604707767L;
+@SuppressWarnings("serial") // Conditionally serializable
 final Queue<E> queue;
 CheckedQueue(Queue<E> queue, Class<E> elementType) {
 super(queue, elementType);
 this.queue = queue;
 * @serial include
 */
 static class CheckedSet<E> extends CheckedCollection<E>
 implements Set<E>, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 4694047833775013803L;
 CheckedSet(Set<E> s, Class<E> elementType) { super(s, elementType); }
 public boolean equals(Object o) { return o == this || c.equals(o); }
 * @serial include
 */
 static class CheckedSortedSet<E> extends CheckedSet<E>
 implements SortedSet<E>, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 1599911165492914959L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final SortedSet<E> ss;
 CheckedSortedSet(SortedSet<E> s, Class<E> type) {
 super(s, type);
 ss = s;
 * @serial include
 */
 static class CheckedNavigableSet<E> extends CheckedSortedSet<E>
 implements NavigableSet<E>, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = -5429120189805438922L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final NavigableSet<E> ns;
 CheckedNavigableSet(NavigableSet<E> s, Class<E> type) {
 super(s, type);
 ns = s;
 */
 static class CheckedList<E>
 extends CheckedCollection<E>
 implements List<E>
 {
+@java.io.Serial
 private static final long serialVersionUID = 65247728283967356L;
+@SuppressWarnings("serial") // Conditionally serializable
 final List<E> list;
 CheckedList(List<E> list, Class<E> type) {
 super(list, type);
 this.list = list;
 * @serial include
 */
 static class CheckedRandomAccessList<E> extends CheckedList<E>
 implements RandomAccess
 {
+@java.io.Serial
 private static final long serialVersionUID = 1638200125423088369L;
 CheckedRandomAccessList(List<E> list, Class<E> type) {
 super(list, type);
 }
 * @serial include
 */
 private static class CheckedMap<K,V>
 implements Map<K,V>, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 5742860141034234728L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final Map<K, V> m;
+@SuppressWarnings("serial") // Conditionally serializable
 final Class<K> keyType;
+@SuppressWarnings("serial") // Conditionally serializable
 final Class<V> valueType;
 private void typeCheck(Object key, Object value) {
 if (key != null && !keyType.isInstance(key))
 throw new ClassCastException(badKeyMsg(key));
 * @serial include
 */
 static class CheckedSortedMap<K,V> extends CheckedMap<K,V>
 implements SortedMap<K,V>, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 1599671320688067438L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final SortedMap<K, V> sm;
 CheckedSortedMap(SortedMap<K, V> m,
 Class<K> keyType, Class<V> valueType) {
 super(m, keyType, valueType);
 * @serial include
 */
 static class CheckedNavigableMap<K,V> extends CheckedSortedMap<K,V>
 implements NavigableMap<K,V>, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = -4852462692372534096L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final NavigableMap<K, V> nm;
 CheckedNavigableMap(NavigableMap<K, V> m,
 Class<K> keyType, Class<V> valueType) {
 super(m, keyType, valueType);
 */
 private static class EmptySet<E>
 extends AbstractSet<E>
 implements Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 1582296315990362920L;
 public Iterator<E> iterator() { return emptyIterator(); }
 public int size() {return 0;}
 }
 @Override
 public Spliterator<E> spliterator() { return Spliterators.emptySpliterator(); }
 // Preserves singleton property
+@java.io.Serial
 private Object readResolve() {
 return EMPTY_SET;
 }
 @Override
 * @serial include
 */
 private static class EmptyList<E>
 extends AbstractList<E>
 implements RandomAccess, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 8842843931221139166L;
 public Iterator<E> iterator() {
 return emptyIterator();
 }
 @Override
 public Spliterator<E> spliterator() { return Spliterators.emptySpliterator(); }
 // Preserves singleton property
+@java.io.Serial
 private Object readResolve() {
 return EMPTY_LIST;
 }
 }
 */
 private static class EmptyMap<K,V>
 extends AbstractMap<K,V>
 implements Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 6428348081105594320L;
 public int size()                          {return 0;}
 public boolean isEmpty()                   {return true;}
 public void clear()                        {}
 BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
 throw new UnsupportedOperationException();
 }
 // Preserves singleton property
+@java.io.Serial
 private Object readResolve() {
 return EMPTY_MAP;
 }
 }
 */
 private static class SingletonSet<E>
 extends AbstractSet<E>
 implements Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 3193687207550431679L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final E element;
 SingletonSet(E e) {element = e;}
 public Iterator<E> iterator() {
 */
 private static class SingletonList<E>
 extends AbstractList<E>
 implements RandomAccess, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 3093736618740652951L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final E element;
 SingletonList(E obj)                {element = obj;}
 public Iterator<E> iterator() {
 * @serial include
 */
 private static class SingletonMap<K,V>
 extends AbstractMap<K,V>
 implements Serializable {
+@java.io.Serial
 private static final long serialVersionUID = -6979724477215052911L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final K k;
+@SuppressWarnings("serial") // Conditionally serializable
 private final V v;
 SingletonMap(K key, V value) {
 k = key;
 v = value;
 */
 private static class CopiesList<E>
 extends AbstractList<E>
 implements RandomAccess, Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 2739099268398711800L;
 final int n;
+@SuppressWarnings("serial") // Conditionally serializable
 final E element;
 CopiesList(int n, E e) {
 assert n >= 0;
 this.n = n;
 @Override
 public Spliterator<E> spliterator() {
 return stream().spliterator();
 }
+@java.io.Serial
+private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ois.defaultReadObject();
+SharedSecrets.getJavaObjectInputStreamAccess().checkArray(ois, Object[].class, n);
+}
 }
 /**
 * Returns a comparator that imposes the reverse of the <em>natural
 * ordering</em> on a collection of objects that implement the
 * @serial include
 */
 private static class ReverseComparator
 implements Comparator<Comparable<Object>>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 7207038068494060240L;
 static final ReverseComparator REVERSE_ORDER
 = new ReverseComparator();
 public int compare(Comparable<Object> c1, Comparable<Object> c2) {
 return c2.compareTo(c1);
 }
+@java.io.Serial
 private Object readResolve() { return Collections.reverseOrder(); }
 @Override
 public Comparator<Comparable<Object>> reversed() {
 return Comparator.naturalOrder();
 * @serial include
 */
 private static class ReverseComparator2<T> implements Comparator<T>,
 Serializable
 {
+@java.io.Serial
 private static final long serialVersionUID = 4374092139857L;
 /**
 * The comparator specified in the static factory.  This will never
 * be null, as the static factory returns a ReverseComparator
 * instance if its argument is null.
 *
 * @serial
 */
+@SuppressWarnings("serial") // Conditionally serializable
 final Comparator<T> cmp;
 ReverseComparator2(Comparator<T> cmp) {
 assert cmp != null;
 this.cmp = cmp;
 * @serial include
 */
 private static class SetFromMap<E> extends AbstractSet<E>
 implements Set<E>, Serializable
 {
+@SuppressWarnings("serial") // Conditionally serializable
 private final Map<E, Boolean> m;  // The backing map
 private transient Set<E> s;       // Its keySet
 SetFromMap(Map<E, Boolean> map) {
 if (!map.isEmpty())
 @Override
 public Stream<E> stream()           {return s.stream();}
 @Override
 public Stream<E> parallelStream()   {return s.parallelStream();}
+@java.io.Serial
 private static final long serialVersionUID = 2454657854757543876L;
+@java.io.Serial
 private void readObject(java.io.ObjectInputStream stream)
 throws IOException, ClassNotFoundException
 {
 stream.defaultReadObject();
 s = m.keySet();
 /**
 * @serial include
 */
 static class AsLIFOQueue<E> extends AbstractQueue<E>
 implements Queue<E>, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 1802017725587941708L;
+@SuppressWarnings("serial") // Conditionally serializable
 private final Deque<E> q;
 AsLIFOQueue(Deque<E> q)                     { this.q = q; }
 public boolean add(E e)                     { q.addFirst(e); return true; }
 public boolean offer(E e)                   { return q.offerFirst(e); }
 public E poll()                             { return q.pollFirst(); }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 53107	cfceb4df2499
child 58679	9c3209ff7550