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

equal deleted inserted replaced

-:7303bc0e78d6
+:0282db800fe1
 * input arrays to n/2 object references for randomly ordered input
 * arrays.
 *
 * <p>The implementation takes equal advantage of ascending and
 * descending order in its input array, and can take advantage of
-* ascending and descending order in different parts of the the same
+* ascending and descending order in different parts of the same
 * input array.  It is well-suited to merging two or more sorted arrays:
 * simply concatenate the arrays and sort the resulting array.
 *
 * <p>The implementation was adapted from Tim Peters's list sort for Python
 * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
 * input arrays to n/2 object references for randomly ordered input
 * arrays.
 *
 * <p>The implementation takes equal advantage of ascending and
 * descending order in its input array, and can take advantage of
-* ascending and descending order in different parts of the the same
+* ascending and descending order in different parts of the same
 * input array.  It is well-suited to merging two or more sorted arrays:
 * simply concatenate the arrays and sort the resulting array.
 *
 * <p>The implementation was adapted from Tim Peters's list sort for Python
 * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
 i += distance;
 if (i >= size)
 i -= size;
 displaced = list.set(i, displaced);
 nMoved ++;
-} while(i != cycleStart);
+} while (i != cycleStart);
 }
 }
 private static void rotate2(List<?> list, int distance) {
 int size = list.size();
 * The next two methods are overridden to protect against
 * an unscrupulous List whose contains(Object o) method senses
 * when o is a Map.Entry, and calls o.setValue.
 */
 public boolean containsAll(Collection<?> coll) {
-Iterator<?> e = coll.iterator();
+Iterator<?> it = coll.iterator();
-while (e.hasNext())
+while (it.hasNext())
-if (!contains(e.next())) // Invokes safe contains() above
+if (!contains(it.next())) // Invokes safe contains() above
 return false;
 return true;
 }
 public boolean equals(Object o) {
 if (o == this)
 private static class UnmodifiableEntry<K,V> implements Map.Entry<K,V> {
 private Map.Entry<? extends K, ? extends V> e;
 UnmodifiableEntry(Map.Entry<? extends K, ? extends V> e) {this.e = e;}
-public K getKey()         {return e.getKey();}
+public K getKey()        {return e.getKey();}
-public V getValue()  {return e.getValue();}
+public V getValue()      {return e.getValue();}
 public V setValue(V value) {
 throw new UnsupportedOperationException();
 }
-public int hashCode()     {return e.hashCode();}
+public int hashCode()    {return e.hashCode();}
 public boolean equals(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
 Map.Entry t = (Map.Entry)o;
 return eq(e.getKey(),   t.getKey()) &&
 eq(e.getValue(), t.getValue());
 }
-public String toString()  {return e.toString();}
+public String toString() {return e.toString();}
 }
 }
 }
 /**
 * It is imperative that the user manually synchronize on the returned
 * collection when iterating over it:
 * <pre>
 *  Collection c = Collections.synchronizedCollection(myCollection);
 *     ...
-*  synchronized(c) {
+*  synchronized (c) {
 *      Iterator i = c.iterator(); // Must be in the synchronized block
 *      while (i.hasNext())
 *         foo(i.next());
 *  }
 * </pre>
 this.c = c;
 this.mutex = mutex;
 }
 public int size() {
-synchronized(mutex) {return c.size();}
+synchronized (mutex) {return c.size();}
 }
 public boolean isEmpty() {
-synchronized(mutex) {return c.isEmpty();}
+synchronized (mutex) {return c.isEmpty();}
 }
 public boolean contains(Object o) {
-synchronized(mutex) {return c.contains(o);}
+synchronized (mutex) {return c.contains(o);}
 }
 public Object[] toArray() {
-synchronized(mutex) {return c.toArray();}
+synchronized (mutex) {return c.toArray();}
 }
 public <T> T[] toArray(T[] a) {
-synchronized(mutex) {return c.toArray(a);}
+synchronized (mutex) {return c.toArray(a);}
 }
 public Iterator<E> iterator() {
 return c.iterator(); // Must be manually synched by user!
 }
 public boolean add(E e) {
-synchronized(mutex) {return c.add(e);}
+synchronized (mutex) {return c.add(e);}
 }
 public boolean remove(Object o) {
-synchronized(mutex) {return c.remove(o);}
+synchronized (mutex) {return c.remove(o);}
 }
 public boolean containsAll(Collection<?> coll) {
-synchronized(mutex) {return c.containsAll(coll);}
+synchronized (mutex) {return c.containsAll(coll);}
 }
 public boolean addAll(Collection<? extends E> coll) {
-synchronized(mutex) {return c.addAll(coll);}
+synchronized (mutex) {return c.addAll(coll);}
 }
 public boolean removeAll(Collection<?> coll) {
-synchronized(mutex) {return c.removeAll(coll);}
+synchronized (mutex) {return c.removeAll(coll);}
 }
 public boolean retainAll(Collection<?> coll) {
-synchronized(mutex) {return c.retainAll(coll);}
+synchronized (mutex) {return c.retainAll(coll);}
 }
 public void clear() {
-synchronized(mutex) {c.clear();}
+synchronized (mutex) {c.clear();}
 }
 public String toString() {
-synchronized(mutex) {return c.toString();}
+synchronized (mutex) {return c.toString();}
 }
 private void writeObject(ObjectOutputStream s) throws IOException {
-synchronized(mutex) {s.defaultWriteObject();}
+synchronized (mutex) {s.defaultWriteObject();}
 }
 }
 /**
 * Returns a synchronized (thread-safe) set backed by the specified
 * It is imperative that the user manually synchronize on the returned
 * set when iterating over it:
 * <pre>
 *  Set s = Collections.synchronizedSet(new HashSet());
 *      ...
-*  synchronized(s) {
+*  synchronized (s) {
 *      Iterator i = s.iterator(); // Must be in the synchronized block
 *      while (i.hasNext())
 *          foo(i.next());
 *  }
 * </pre>
 SynchronizedSet(Set<E> s, Object mutex) {
 super(s, mutex);
 }
 public boolean equals(Object o) {
-synchronized(mutex) {return c.equals(o);}
+synchronized (mutex) {return c.equals(o);}
 }
 public int hashCode() {
-synchronized(mutex) {return c.hashCode();}
+synchronized (mutex) {return c.hashCode();}
 }
 }
 /**
 * Returns a synchronized (thread-safe) sorted set backed by the specified
 * sorted set when iterating over it or any of its <tt>subSet</tt>,
 * <tt>headSet</tt>, or <tt>tailSet</tt> views.
 * <pre>
 *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
 *      ...
-*  synchronized(s) {
+*  synchronized (s) {
 *      Iterator i = s.iterator(); // Must be in the synchronized block
 *      while (i.hasNext())
 *          foo(i.next());
 *  }
 * </pre>
 * or:
 * <pre>
 *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
 *  SortedSet s2 = s.headSet(foo);
 *      ...
-*  synchronized(s) {  // Note: s, not s2!!!
+*  synchronized (s) {  // Note: s, not s2!!!
 *      Iterator i = s2.iterator(); // Must be in the synchronized block
 *      while (i.hasNext())
 *          foo(i.next());
 *  }
 * </pre>
 extends SynchronizedSet<E>
 implements SortedSet<E>
 {
 private static final long serialVersionUID = 8695801310862127406L;
-final private SortedSet<E> ss;
+private final SortedSet<E> ss;
 SynchronizedSortedSet(SortedSet<E> s) {
 super(s);
 ss = s;
 }
 super(s, mutex);
 ss = s;
 }
 public Comparator<? super E> comparator() {
-synchronized(mutex) {return ss.comparator();}
+synchronized (mutex) {return ss.comparator();}
 }
 public SortedSet<E> subSet(E fromElement, E toElement) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedSortedSet<E>(
 ss.subSet(fromElement, toElement), mutex);
 }
 }
 public SortedSet<E> headSet(E toElement) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedSortedSet<E>(ss.headSet(toElement), mutex);
 }
 }
 public SortedSet<E> tailSet(E fromElement) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedSortedSet<E>(ss.tailSet(fromElement),mutex);
 }
 }
 public E first() {
-synchronized(mutex) {return ss.first();}
+synchronized (mutex) {return ss.first();}
 }
 public E last() {
-synchronized(mutex) {return ss.last();}
+synchronized (mutex) {return ss.last();}
 }
 }
 /**
 * Returns a synchronized (thread-safe) list backed by the specified
 * It is imperative that the user manually synchronize on the returned
 * list when iterating over it:
 * <pre>
 *  List list = Collections.synchronizedList(new ArrayList());
 *      ...
-*  synchronized(list) {
+*  synchronized (list) {
 *      Iterator i = list.iterator(); // Must be in synchronized block
 *      while (i.hasNext())
 *          foo(i.next());
 *  }
 * </pre>
 super(list, mutex);
 this.list = list;
 }
 public boolean equals(Object o) {
-synchronized(mutex) {return list.equals(o);}
+synchronized (mutex) {return list.equals(o);}
 }
 public int hashCode() {
-synchronized(mutex) {return list.hashCode();}
+synchronized (mutex) {return list.hashCode();}
 }
 public E get(int index) {
-synchronized(mutex) {return list.get(index);}
+synchronized (mutex) {return list.get(index);}
 }
 public E set(int index, E element) {
-synchronized(mutex) {return list.set(index, element);}
+synchronized (mutex) {return list.set(index, element);}
 }
 public void add(int index, E element) {
-synchronized(mutex) {list.add(index, element);}
+synchronized (mutex) {list.add(index, element);}
 }
 public E remove(int index) {
-synchronized(mutex) {return list.remove(index);}
+synchronized (mutex) {return list.remove(index);}
 }
 public int indexOf(Object o) {
-synchronized(mutex) {return list.indexOf(o);}
+synchronized (mutex) {return list.indexOf(o);}
 }
 public int lastIndexOf(Object o) {
-synchronized(mutex) {return list.lastIndexOf(o);}
+synchronized (mutex) {return list.lastIndexOf(o);}
 }
 public boolean addAll(int index, Collection<? extends E> c) {
-synchronized(mutex) {return list.addAll(index, c);}
+synchronized (mutex) {return list.addAll(index, c);}
 }
 public ListIterator<E> listIterator() {
 return list.listIterator(); // Must be manually synched by user
 }
 public ListIterator<E> listIterator(int index) {
 return list.listIterator(index); // Must be manually synched by user
 }
 public List<E> subList(int fromIndex, int toIndex) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedList<E>(list.subList(fromIndex, toIndex),
 mutex);
 }
 }
 SynchronizedRandomAccessList(List<E> list, Object mutex) {
 super(list, mutex);
 }
 public List<E> subList(int fromIndex, int toIndex) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedRandomAccessList<E>(
 list.subList(fromIndex, toIndex), mutex);
 }
 }
 * <pre>
 *  Map m = Collections.synchronizedMap(new HashMap());
 *      ...
 *  Set s = m.keySet();  // Needn't be in synchronized block
 *      ...
-*  synchronized(m) {  // Synchronizing on m, not s!
+*  synchronized (m) {  // Synchronizing on m, not s!
 *      Iterator i = s.iterator(); // Must be in synchronized block
 *      while (i.hasNext())
 *          foo(i.next());
 *  }
 * </pre>
 this.m = m;
 this.mutex = mutex;
 }
 public int size() {
-synchronized(mutex) {return m.size();}
+synchronized (mutex) {return m.size();}
 }
 public boolean isEmpty() {
-synchronized(mutex) {return m.isEmpty();}
+synchronized (mutex) {return m.isEmpty();}
 }
 public boolean containsKey(Object key) {
-synchronized(mutex) {return m.containsKey(key);}
+synchronized (mutex) {return m.containsKey(key);}
 }
 public boolean containsValue(Object value) {
-synchronized(mutex) {return m.containsValue(value);}
+synchronized (mutex) {return m.containsValue(value);}
 }
 public V get(Object key) {
-synchronized(mutex) {return m.get(key);}
+synchronized (mutex) {return m.get(key);}
 }
 public V put(K key, V value) {
-synchronized(mutex) {return m.put(key, value);}
+synchronized (mutex) {return m.put(key, value);}
 }
 public V remove(Object key) {
-synchronized(mutex) {return m.remove(key);}
+synchronized (mutex) {return m.remove(key);}
 }
 public void putAll(Map<? extends K, ? extends V> map) {
-synchronized(mutex) {m.putAll(map);}
+synchronized (mutex) {m.putAll(map);}
 }
 public void clear() {
-synchronized(mutex) {m.clear();}
+synchronized (mutex) {m.clear();}
 }
 private transient Set<K> keySet = null;
 private transient Set<Map.Entry<K,V>> entrySet = null;
 private transient Collection<V> values = null;
 public Set<K> keySet() {
-synchronized(mutex) {
+synchronized (mutex) {
 if (keySet==null)
 keySet = new SynchronizedSet<K>(m.keySet(), mutex);
 return keySet;
 }
 }
 public Set<Map.Entry<K,V>> entrySet() {
-synchronized(mutex) {
+synchronized (mutex) {
 if (entrySet==null)
 entrySet = new SynchronizedSet<Map.Entry<K,V>>(m.entrySet(), mutex);
 return entrySet;
 }
 }
 public Collection<V> values() {
-synchronized(mutex) {
+synchronized (mutex) {
 if (values==null)
 values = new SynchronizedCollection<V>(m.values(), mutex);
 return values;
 }
 }
 public boolean equals(Object o) {
-synchronized(mutex) {return m.equals(o);}
+synchronized (mutex) {return m.equals(o);}
 }
 public int hashCode() {
-synchronized(mutex) {return m.hashCode();}
+synchronized (mutex) {return m.hashCode();}
 }
 public String toString() {
-synchronized(mutex) {return m.toString();}
+synchronized (mutex) {return m.toString();}
 }
 private void writeObject(ObjectOutputStream s) throws IOException {
-synchronized(mutex) {s.defaultWriteObject();}
+synchronized (mutex) {s.defaultWriteObject();}
 }
 }
 /**
 * Returns a synchronized (thread-safe) sorted map backed by the specified
 * <pre>
 *  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
 *      ...
 *  Set s = m.keySet();  // Needn't be in synchronized block
 *      ...
-*  synchronized(m) {  // Synchronizing on m, not s!
+*  synchronized (m) {  // Synchronizing on m, not s!
 *      Iterator i = s.iterator(); // Must be in synchronized block
 *      while (i.hasNext())
 *          foo(i.next());
 *  }
 * </pre>
 *  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
 *  SortedMap m2 = m.subMap(foo, bar);
 *      ...
 *  Set s2 = m2.keySet();  // Needn't be in synchronized block
 *      ...
-*  synchronized(m) {  // Synchronizing on m, not m2 or s2!
+*  synchronized (m) {  // Synchronizing on m, not m2 or s2!
 *      Iterator i = s.iterator(); // Must be in synchronized block
 *      while (i.hasNext())
 *          foo(i.next());
 *  }
 * </pre>
 super(m, mutex);
 sm = m;
 }
 public Comparator<? super K> comparator() {
-synchronized(mutex) {return sm.comparator();}
+synchronized (mutex) {return sm.comparator();}
 }
 public SortedMap<K,V> subMap(K fromKey, K toKey) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedSortedMap<K,V>(
 sm.subMap(fromKey, toKey), mutex);
 }
 }
 public SortedMap<K,V> headMap(K toKey) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedSortedMap<K,V>(sm.headMap(toKey), mutex);
 }
 }
 public SortedMap<K,V> tailMap(K fromKey) {
-synchronized(mutex) {
+synchronized (mutex) {
 return new SynchronizedSortedMap<K,V>(sm.tailMap(fromKey),mutex);
 }
 }
 public K firstKey() {
-synchronized(mutex) {return sm.firstKey();}
+synchronized (mutex) {return sm.firstKey();}
 }
 public K lastKey() {
-synchronized(mutex) {return sm.lastKey();}
+synchronized (mutex) {return sm.lastKey();}
 }
 }
 // Dynamically typesafe collection wrappers
 extends AbstractSet<E>
 implements Serializable
 {
 private static final long serialVersionUID = 3193687207550431679L;
-final private E element;
+private final E element;
 SingletonSet(E e) {element = e;}
 public Iterator<E> iterator() {
 return singletonIterator(element);
 *
 * @param  n the number of elements in the returned list.
 * @param  o the element to appear repeatedly in the returned list.
 * @return an immutable list consisting of <tt>n</tt> copies of the
 *         specified object.
-* @throws IllegalArgumentException if n &lt; 0.
+* @throws IllegalArgumentException if {@code n < 0}
 * @see    List#addAll(Collection)
 * @see    List#addAll(int, Collection)
 */
 public static <T> List<T> nCopies(int n, T o) {
 if (n < 0)

changeset 7518	0282db800fe1
parent 5781	11a42d91eb56
child 7668	d4a77089c587
child 7803	56bc97d69d93