src/share/classes/java/util/Collections.java
Print this page
@@ -122,11 +122,11 @@
* 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">
@@ -182,11 +182,11 @@
* 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">
@@ -821,11 +821,11 @@
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();
@@ -1450,13 +1450,13 @@
* 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();
- while (e.hasNext())
- if (!contains(e.next())) // Invokes safe contains() above
+ Iterator<?> it = coll.iterator();
+ while (it.hasNext())
+ if (!contains(it.next())) // Invokes safe contains() above
return false;
return true;
}
public boolean equals(Object o) {
if (o == this)
@@ -1560,11 +1560,11 @@
* 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>
@@ -1609,56 +1609,56 @@
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
@@ -1669,11 +1669,11 @@
* 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>
@@ -1707,14 +1707,14 @@
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
@@ -1726,11 +1726,11 @@
* 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>
@@ -1737,11 +1737,11 @@
* 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>
@@ -1764,11 +1764,11 @@
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;
}
@@ -1776,35 +1776,35 @@
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
@@ -1815,11 +1815,11 @@
* 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>
@@ -1861,38 +1861,38 @@
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
}
@@ -1900,11 +1900,11 @@
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);
}
}
@@ -1941,11 +1941,11 @@
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);
}
}
@@ -1973,11 +1973,11 @@
* <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>
@@ -2014,77 +2014,77 @@
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
@@ -2099,11 +2099,11 @@
* <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>
@@ -2112,11 +2112,11 @@
* 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>
@@ -2152,35 +2152,35 @@
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
@@ -3315,11 +3315,11 @@
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);
@@ -3446,11 +3446,11 @@
*
* @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 < 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)