You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by nd...@apache.org on 2006/06/09 06:59:16 UTC
svn commit: r412928 -
/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/Collections.java
Author: ndbeyer
Date: Thu Jun 8 21:59:15 2006
New Revision: 412928
URL: http://svn.apache.org/viewvc?rev=412928&view=rev
Log:
Generification of methods.
Modified:
incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/Collections.java
Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/Collections.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/Collections.java?rev=412928&r1=412927&r2=412928&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/Collections.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/Collections.java Thu Jun 8 21:59:15 2006
@@ -27,15 +27,15 @@
*/
public class Collections {
- private static final class CopiesList extends AbstractList implements
+ private static final class CopiesList<E> extends AbstractList<E> implements
Serializable {
private static final long serialVersionUID = 2739099268398711800L;
private final int n;
- private final Object element;
+ private final E element;
- CopiesList(int length, Object object) {
+ CopiesList(int length, E object) {
if (length < 0) {
throw new IllegalArgumentException();
}
@@ -51,7 +51,7 @@
return n;
}
- public Object get(int location) {
+ public E get(int location) {
if (0 <= location && location < n)
return element;
throw new IndexOutOfBoundsException();
@@ -162,13 +162,13 @@
}
}
- private static final class SingletonSet extends AbstractSet implements
+ private static final class SingletonSet<E> extends AbstractSet<E> implements
Serializable {
private static final long serialVersionUID = 3193687207550431679L;
- final Object element;
+ final E element;
- SingletonSet(Object object) {
+ SingletonSet(E object) {
element = object;
}
@@ -180,15 +180,15 @@
return 1;
}
- public Iterator iterator() {
- return new Iterator() {
+ public Iterator<E> iterator() {
+ return new Iterator<E>() {
boolean hasNext = true;
public boolean hasNext() {
return hasNext;
}
- public Object next() {
+ public E next() {
if (hasNext) {
hasNext = false;
return element;
@@ -203,13 +203,13 @@
}
}
- private static final class SingletonList extends AbstractList implements
+ private static final class SingletonList<E> extends AbstractList<E> implements
Serializable {
private static final long serialVersionUID = 3093736618740652951L;
- final Object element;
+ final E element;
- SingletonList(Object object) {
+ SingletonList(E object) {
element = object;
}
@@ -217,7 +217,7 @@
return element == null ? object == null : element.equals(object);
}
- public Object get(int location) {
+ public E get(int location) {
if (location == 0)
return element;
throw new IndexOutOfBoundsException();
@@ -228,13 +228,14 @@
}
}
- private static final class SingletonMap extends AbstractMap implements
+ private static final class SingletonMap<K, V> extends AbstractMap<K, V> implements
Serializable {
private static final long serialVersionUID = -6979724477215052911L;
- final Object k, v;
+ final K k;
+ final V v;
- SingletonMap(Object key, Object value) {
+ SingletonMap(K key, V value) {
k = key;
v = value;
}
@@ -247,7 +248,7 @@
return v == null ? value == null : v.equals(value);
}
- public Object get(Object key) {
+ public V get(Object key) {
if (containsKey(key))
return v;
return null;
@@ -257,11 +258,11 @@
return 1;
}
- public Set entrySet() {
- return new AbstractSet() {
+ public Set<Map.Entry<K, V>> entrySet() {
+ return new AbstractSet<Map.Entry<K, V>>() {
public boolean contains(Object object) {
if (object instanceof Map.Entry) {
- Map.Entry entry = (Map.Entry) object;
+ Map.Entry<?, ?> entry = (Map.Entry) object;
return containsKey(entry.getKey())
&& containsValue(entry.getValue());
}
@@ -272,27 +273,27 @@
return 1;
}
- public Iterator iterator() {
- return new Iterator() {
+ public Iterator<Map.Entry<K, V>> iterator() {
+ return new Iterator<Map.Entry<K, V>>() {
boolean hasNext = true;
public boolean hasNext() {
return hasNext;
}
- public Object next() {
+ public Map.Entry<K, V> next() {
if (hasNext) {
hasNext = false;
- return new Map.Entry() {
+ return new Map.Entry<K, V>() {
public boolean equals(Object object) {
return contains(object);
}
- public Object getKey() {
+ public K getKey() {
return k;
}
- public Object getValue() {
+ public V getValue() {
return v;
}
@@ -301,7 +302,7 @@
^ (v == null ? 0 : v.hashCode());
}
- public Object setValue(Object value) {
+ public V setValue(V value) {
throw new UnsupportedOperationException();
}
};
@@ -318,29 +319,29 @@
}
}
- static class SynchronizedCollection implements Collection, Serializable {
+ static class SynchronizedCollection<E> implements Collection<E>, Serializable {
private static final long serialVersionUID = 3053995032091335093L;
- final Collection c;
+ final Collection<E> c;
final Object mutex;
- SynchronizedCollection(Collection collection) {
+ SynchronizedCollection(Collection<E> collection) {
c = collection;
mutex = this;
}
- SynchronizedCollection(Collection collection, Object mutex) {
+ SynchronizedCollection(Collection<E> collection, Object mutex) {
c = collection;
this.mutex = mutex;
}
- public boolean add(Object object) {
+ public boolean add(E object) {
synchronized (mutex) {
return c.add(object);
}
}
- public boolean addAll(Collection collection) {
+ public boolean addAll(Collection<? extends E> collection) {
synchronized (mutex) {
return c.addAll(collection);
}
@@ -358,7 +359,7 @@
}
}
- public boolean containsAll(Collection collection) {
+ public boolean containsAll(Collection<?> collection) {
synchronized (mutex) {
return c.containsAll(collection);
}
@@ -370,7 +371,7 @@
}
}
- public Iterator iterator() {
+ public Iterator<E> iterator() {
synchronized (mutex) {
return c.iterator();
}
@@ -382,13 +383,13 @@
}
}
- public boolean removeAll(Collection collection) {
+ public boolean removeAll(Collection<?> collection) {
synchronized (mutex) {
return c.removeAll(collection);
}
}
- public boolean retainAll(Collection collection) {
+ public boolean retainAll(Collection<?> collection) {
synchronized (mutex) {
return c.retainAll(collection);
}
@@ -412,7 +413,7 @@
}
}
- public Object[] toArray(Object[] array) {
+ public <T> T[] toArray(T[] array) {
synchronized (mutex) {
return c.toArray(array);
}
@@ -425,21 +426,21 @@
}
}
- static class SynchronizedRandomAccessList extends SynchronizedList
+ static class SynchronizedRandomAccessList<E> extends SynchronizedList<E>
implements RandomAccess {
private static final long serialVersionUID = 1530674583602358482L;
- SynchronizedRandomAccessList(List l) {
+ SynchronizedRandomAccessList(List<E> l) {
super(l);
}
- SynchronizedRandomAccessList(List l, Object mutex) {
+ SynchronizedRandomAccessList(List<E> l, Object mutex) {
super(l, mutex);
}
- public List subList(int start, int end) {
+ public List<E> subList(int start, int end) {
synchronized (mutex) {
- return new SynchronizedRandomAccessList(list
+ return new SynchronizedRandomAccessList<E>(list
.subList(start, end), mutex);
}
}
@@ -455,33 +456,33 @@
* @see SynchronizedList#readResolve()
*/
private Object writeReplace() {
- return new SynchronizedList(list);
+ return new SynchronizedList<E>(list);
}
}
- static class SynchronizedList extends SynchronizedCollection implements
- List {
+ static class SynchronizedList<E> extends SynchronizedCollection<E> implements
+ List<E> {
private static final long serialVersionUID = -7754090372962971524L;
- final List list;
+ final List<E> list;
- SynchronizedList(List l) {
+ SynchronizedList(List<E> l) {
super(l);
list = l;
}
- SynchronizedList(List l, Object mutex) {
+ SynchronizedList(List<E> l, Object mutex) {
super(l, mutex);
list = l;
}
- public void add(int location, Object object) {
+ public void add(int location, E object) {
synchronized (mutex) {
list.add(location, object);
}
}
- public boolean addAll(int location, Collection collection) {
+ public boolean addAll(int location, Collection<? extends E> collection) {
synchronized (mutex) {
return list.addAll(location, collection);
}
@@ -493,7 +494,7 @@
}
}
- public Object get(int location) {
+ public E get(int location) {
synchronized (mutex) {
return list.get(location);
}
@@ -517,33 +518,33 @@
}
}
- public ListIterator listIterator() {
+ public ListIterator<E> listIterator() {
synchronized (mutex) {
return list.listIterator();
}
}
- public ListIterator listIterator(int location) {
+ public ListIterator<E> listIterator(int location) {
synchronized (mutex) {
return list.listIterator(location);
}
}
- public Object remove(int location) {
+ public E remove(int location) {
synchronized (mutex) {
return list.remove(location);
}
}
- public Object set(int location, Object object) {
+ public E set(int location, E object) {
synchronized (mutex) {
return list.set(location, object);
}
}
- public List subList(int start, int end) {
+ public List<E> subList(int start, int end) {
synchronized (mutex) {
- return new SynchronizedList(list.subList(start, end), mutex);
+ return new SynchronizedList<E>(list.subList(start, end), mutex);
}
}
@@ -569,24 +570,24 @@
*/
private Object readResolve() {
if (list instanceof RandomAccess)
- return new SynchronizedRandomAccessList(list, mutex);
+ return new SynchronizedRandomAccessList<E>(list, mutex);
else
return this;
}
}
- static class SynchronizedMap implements Map, Serializable {
+ static class SynchronizedMap<K, V> implements Map<K, V>, Serializable {
private static final long serialVersionUID = 1978198479659022715L;
- private final Map m;
+ private final Map<K, V> m;
final Object mutex;
- SynchronizedMap(Map map) {
+ SynchronizedMap(Map<K, V> map) {
m = map;
mutex = this;
}
- SynchronizedMap(Map map, Object mutex) {
+ SynchronizedMap(Map<K, V> map, Object mutex) {
m = map;
this.mutex = mutex;
}
@@ -609,9 +610,9 @@
}
}
- public Set entrySet() {
+ public Set<Map.Entry<K, V>> entrySet() {
synchronized (mutex) {
- return new SynchronizedSet(m.entrySet(), mutex);
+ return new SynchronizedSet<Map.Entry<K, V>>(m.entrySet(), mutex);
}
}
@@ -621,7 +622,7 @@
}
}
- public Object get(Object key) {
+ public V get(Object key) {
synchronized (mutex) {
return m.get(key);
}
@@ -639,25 +640,25 @@
}
}
- public Set keySet() {
+ public Set<K> keySet() {
synchronized (mutex) {
- return new SynchronizedSet(m.keySet(), mutex);
+ return new SynchronizedSet<K>(m.keySet(), mutex);
}
}
- public Object put(Object key, Object value) {
+ public V put(K key, V value) {
synchronized (mutex) {
return m.put(key, value);
}
}
- public void putAll(Map map) {
+ public void putAll(Map<? extends K, ? extends V> map) {
synchronized (mutex) {
m.putAll(map);
}
}
- public Object remove(Object key) {
+ public V remove(Object key) {
synchronized (mutex) {
return m.remove(key);
}
@@ -669,9 +670,9 @@
}
}
- public Collection values() {
+ public Collection<V> values() {
synchronized (mutex) {
- return new SynchronizedCollection(m.values(), mutex);
+ return new SynchronizedCollection<V>(m.values(), mutex);
}
}
@@ -688,14 +689,14 @@
}
}
- static class SynchronizedSet extends SynchronizedCollection implements Set {
+ static class SynchronizedSet<E> extends SynchronizedCollection<E> implements Set<E> {
private static final long serialVersionUID = 487447009682186044L;
- SynchronizedSet(Set set) {
+ SynchronizedSet(Set<E> set) {
super(set);
}
- SynchronizedSet(Set set, Object mutex) {
+ SynchronizedSet(Set<E> set, Object mutex) {
super(set, mutex);
}
@@ -718,56 +719,56 @@
}
}
- static class SynchronizedSortedMap extends SynchronizedMap implements
- SortedMap {
+ static class SynchronizedSortedMap<K, V> extends SynchronizedMap<K, V> implements
+ SortedMap<K, V> {
private static final long serialVersionUID = -8798146769416483793L;
- private final SortedMap sm;
+ private final SortedMap<K, V> sm;
- SynchronizedSortedMap(SortedMap map) {
+ SynchronizedSortedMap(SortedMap<K, V> map) {
super(map);
sm = map;
}
- SynchronizedSortedMap(SortedMap map, Object mutex) {
+ SynchronizedSortedMap(SortedMap<K, V> map, Object mutex) {
super(map, mutex);
sm = map;
}
- public Comparator comparator() {
+ public Comparator<? super K> comparator() {
synchronized (mutex) {
return sm.comparator();
}
}
- public Object firstKey() {
+ public K firstKey() {
synchronized (mutex) {
return sm.firstKey();
}
}
- public SortedMap headMap(Object endKey) {
+ public SortedMap<K, V> headMap(K endKey) {
synchronized (mutex) {
- return new SynchronizedSortedMap(sm.headMap(endKey), mutex);
+ return new SynchronizedSortedMap<K, V>(sm.headMap(endKey), mutex);
}
}
- public Object lastKey() {
+ public K lastKey() {
synchronized (mutex) {
return sm.lastKey();
}
}
- public SortedMap subMap(Object startKey, Object endKey) {
+ public SortedMap<K, V> subMap(K startKey, K endKey) {
synchronized (mutex) {
- return new SynchronizedSortedMap(sm.subMap(startKey, endKey),
+ return new SynchronizedSortedMap<K, V>(sm.subMap(startKey, endKey),
mutex);
}
}
- public SortedMap tailMap(Object startKey) {
+ public SortedMap<K, V> tailMap(K startKey) {
synchronized (mutex) {
- return new SynchronizedSortedMap(sm.tailMap(startKey), mutex);
+ return new SynchronizedSortedMap<K, V>(sm.tailMap(startKey), mutex);
}
}
@@ -778,55 +779,55 @@
}
}
- static class SynchronizedSortedSet extends SynchronizedSet implements
- SortedSet {
+ static class SynchronizedSortedSet<E> extends SynchronizedSet<E> implements
+ SortedSet<E> {
private static final long serialVersionUID = 8695801310862127406L;
- private final SortedSet ss;
+ private final SortedSet<E> ss;
- SynchronizedSortedSet(SortedSet set) {
+ SynchronizedSortedSet(SortedSet<E> set) {
super(set);
ss = set;
}
- SynchronizedSortedSet(SortedSet set, Object mutex) {
+ SynchronizedSortedSet(SortedSet<E> set, Object mutex) {
super(set, mutex);
ss = set;
}
- public Comparator comparator() {
+ public Comparator<? super E> comparator() {
synchronized (mutex) {
return ss.comparator();
}
}
- public Object first() {
+ public E first() {
synchronized (mutex) {
return ss.first();
}
}
- public SortedSet headSet(Object end) {
+ public SortedSet<E> headSet(E end) {
synchronized (mutex) {
- return new SynchronizedSortedSet(ss.headSet(end), mutex);
+ return new SynchronizedSortedSet<E>(ss.headSet(end), mutex);
}
}
- public Object last() {
+ public E last() {
synchronized (mutex) {
return ss.last();
}
}
- public SortedSet subSet(Object start, Object end) {
+ public SortedSet<E> subSet(E start, E end) {
synchronized (mutex) {
- return new SynchronizedSortedSet(ss.subSet(start, end), mutex);
+ return new SynchronizedSortedSet<E>(ss.subSet(start, end), mutex);
}
}
- public SortedSet tailSet(Object start) {
+ public SortedSet<E> tailSet(E start) {
synchronized (mutex) {
- return new SynchronizedSortedSet(ss.tailSet(start), mutex);
+ return new SynchronizedSortedSet<E>(ss.tailSet(start), mutex);
}
}
@@ -837,13 +838,13 @@
}
}
- private static class UnmodifiableCollection implements Collection,
+ private static class UnmodifiableCollection<E> implements Collection<E>,
Serializable {
private static final long serialVersionUID = 1820017752578914078L;
- final Collection c;
+ final Collection<E> c;
- UnmodifiableCollection(Collection collection) {
+ UnmodifiableCollection(Collection<E> collection) {
c = collection;
}
@@ -851,7 +852,7 @@
throw new UnsupportedOperationException();
}
- public boolean addAll(Collection collection) {
+ public boolean addAll(Collection<? extends E> collection) {
throw new UnsupportedOperationException();
}
@@ -863,7 +864,7 @@
return c.contains(object);
}
- public boolean containsAll(Collection collection) {
+ public boolean containsAll(Collection<?> collection) {
return c.containsAll(collection);
}
@@ -871,15 +872,15 @@
return c.isEmpty();
}
- public Iterator iterator() {
- return new Iterator() {
- Iterator iterator = c.iterator();
+ public Iterator<E> iterator() {
+ return new Iterator<E>() {
+ Iterator<E> iterator = c.iterator();
public boolean hasNext() {
return iterator.hasNext();
}
- public Object next() {
+ public E next() {
return iterator.next();
}
@@ -893,11 +894,11 @@
throw new UnsupportedOperationException();
}
- public boolean removeAll(Collection collection) {
+ public boolean removeAll(Collection<?> collection) {
throw new UnsupportedOperationException();
}
- public boolean retainAll(Collection collection) {
+ public boolean retainAll(Collection<?> collection) {
throw new UnsupportedOperationException();
}
@@ -905,11 +906,11 @@
return c.size();
}
- public java.lang.Object[] toArray() {
+ public Object[] toArray() {
return c.toArray();
}
- public Object[] toArray(Object[] array) {
+ public <T> T[] toArray(T[] array) {
return c.toArray(array);
}
@@ -918,16 +919,16 @@
}
}
- private static class UnmodifiableRandomAccessList extends UnmodifiableList
+ private static class UnmodifiableRandomAccessList<E> extends UnmodifiableList<E>
implements RandomAccess {
private static final long serialVersionUID = -2542308836966382001L;
- UnmodifiableRandomAccessList(List l) {
+ UnmodifiableRandomAccessList(List<E> l) {
super(l);
}
- public List subList(int start, int end) {
- return new UnmodifiableRandomAccessList(list.subList(start, end));
+ public List<E> subList(int start, int end) {
+ return new UnmodifiableRandomAccessList<E>(list.subList(start, end));
}
/**
@@ -941,26 +942,26 @@
* @see UnmodifiableList#readResolve()
*/
private Object writeReplace() {
- return new UnmodifiableList(list);
+ return new UnmodifiableList<E>(list);
}
}
- private static class UnmodifiableList extends UnmodifiableCollection
- implements List {
+ private static class UnmodifiableList<E> extends UnmodifiableCollection<E>
+ implements List<E> {
private static final long serialVersionUID = -283967356065247728L;
- final List list;
+ final List<E> list;
- UnmodifiableList(List l) {
+ UnmodifiableList(List<E> l) {
super(l);
list = l;
}
- public void add(int location, Object object) {
+ public void add(int location, E object) {
throw new UnsupportedOperationException();
}
- public boolean addAll(int location, Collection collection) {
+ public boolean addAll(int location, Collection<? extends E> collection) {
throw new UnsupportedOperationException();
}
@@ -968,7 +969,7 @@
return list.equals(object);
}
- public Object get(int location) {
+ public E get(int location) {
return list.get(location);
}
@@ -984,15 +985,15 @@
return list.lastIndexOf(object);
}
- public ListIterator listIterator() {
+ public ListIterator<E> listIterator() {
return listIterator(0);
}
- public ListIterator listIterator(final int location) {
- return new ListIterator() {
- ListIterator iterator = list.listIterator(location);
+ public ListIterator<E> listIterator(final int location) {
+ return new ListIterator<E>() {
+ ListIterator<E> iterator = list.listIterator(location);
- public void add(Object object) {
+ public void add(E object) {
throw new UnsupportedOperationException();
}
@@ -1004,7 +1005,7 @@
return iterator.hasPrevious();
}
- public Object next() {
+ public E next() {
return iterator.next();
}
@@ -1012,7 +1013,7 @@
return iterator.nextIndex();
}
- public Object previous() {
+ public E previous() {
return iterator.previous();
}
@@ -1030,16 +1031,16 @@
};
}
- public Object remove(int location) {
+ public E remove(int location) {
throw new UnsupportedOperationException();
}
- public Object set(int location, Object object) {
+ public E set(int location, E object) {
throw new UnsupportedOperationException();
}
- public List subList(int start, int end) {
- return new UnmodifiableList(list.subList(start, end));
+ public List<E> subList(int start, int end) {
+ return new UnmodifiableList<E>(list.subList(start, end));
}
/**
@@ -1059,24 +1060,24 @@
*/
private Object readResolve() {
if (list instanceof RandomAccess)
- return new UnmodifiableRandomAccessList(list);
+ return new UnmodifiableRandomAccessList<E>(list);
else
return this;
}
}
- private static class UnmodifiableMap implements Map, Serializable {
+ private static class UnmodifiableMap<K, V> implements Map<K, V>, Serializable {
private static final long serialVersionUID = -1034234728574286014L;
- private final Map m;
+ private final Map<K, V> m;
- private static class UnmodifiableEntrySet extends UnmodifiableSet {
+ private static class UnmodifiableEntrySet<K, V> extends UnmodifiableSet<Map.Entry<K, V>> {
private static final long serialVersionUID = 7854390611657943733L;
- private static class UnmodifiableMapEntry implements Map.Entry {
- Map.Entry mapEntry;
+ private static class UnmodifiableMapEntry<K, V> implements Map.Entry<K, V> {
+ Map.Entry<K, V> mapEntry;
- UnmodifiableMapEntry(Map.Entry entry) {
+ UnmodifiableMapEntry(Map.Entry<K, V> entry) {
mapEntry = entry;
}
@@ -1084,11 +1085,11 @@
return mapEntry.equals(object);
}
- public Object getKey() {
+ public K getKey() {
return mapEntry.getKey();
}
- public Object getValue() {
+ public V getValue() {
return mapEntry.getValue();
}
@@ -1096,7 +1097,7 @@
return mapEntry.hashCode();
}
- public Object setValue(Object object) {
+ public V setValue(V object) {
throw new UnsupportedOperationException();
}
@@ -1105,21 +1106,20 @@
}
}
- UnmodifiableEntrySet(Set set) {
+ UnmodifiableEntrySet(Set<Map.Entry<K, V>> set) {
super(set);
}
- public Iterator iterator() {
- return new Iterator() {
- Iterator iterator = c.iterator();
+ public Iterator<Map.Entry<K, V>> iterator() {
+ return new Iterator<Map.Entry<K, V>>() {
+ Iterator<Map.Entry<K, V>> iterator = c.iterator();
public boolean hasNext() {
return iterator.hasNext();
}
- public Object next() {
- return new UnmodifiableMapEntry((Map.Entry) iterator
- .next());
+ public Map.Entry<K, V> next() {
+ return new UnmodifiableMapEntry<K, V>(iterator.next());
}
public void remove() {
@@ -1131,27 +1131,30 @@
public Object[] toArray() {
int length = c.size();
Object[] result = new Object[length];
- Iterator it = iterator();
+ Iterator<?> it = iterator();
for (int i = length; --i >= 0;)
result[i] = it.next();
return result;
}
- public Object[] toArray(Object[] contents) {
+ public <T> T[] toArray(T[] contents) {
int size = c.size(), index = 0;
- Iterator it = iterator();
- if (size > contents.length)
- contents = (Object[]) Array.newInstance(contents.getClass()
- .getComponentType(), size);
- while (index < size)
- contents[index++] = it.next();
- if (index < contents.length)
+ Iterator<Map.Entry<K, V>> it = iterator();
+ if (size > contents.length) {
+ Class<?> ct = contents.getClass().getComponentType();
+ contents = (T[])Array.newInstance(ct, size);
+ }
+ while (index < size) {
+ contents[index++] = (T)it.next();
+ }
+ if (index < contents.length) {
contents[index] = null;
+ }
return contents;
}
}
- UnmodifiableMap(Map map) {
+ UnmodifiableMap(Map<K, V> map) {
m = map;
}
@@ -1167,15 +1170,15 @@
return m.containsValue(value);
}
- public Set entrySet() {
- return new UnmodifiableEntrySet(m.entrySet());
+ public Set<Map.Entry<K, V>> entrySet() {
+ return new UnmodifiableEntrySet<K, V>(m.entrySet());
}
public boolean equals(Object object) {
return m.equals(object);
}
- public Object get(Object key) {
+ public V get(Object key) {
return m.get(key);
}
@@ -1187,19 +1190,19 @@
return m.isEmpty();
}
- public Set keySet() {
- return new UnmodifiableSet(m.keySet());
+ public Set<K> keySet() {
+ return new UnmodifiableSet<K>(m.keySet());
}
- public Object put(Object key, Object value) {
+ public V put(K key, V value) {
throw new UnsupportedOperationException();
}
- public void putAll(Map map) {
+ public void putAll(Map<? extends K, ? extends V> map) {
throw new UnsupportedOperationException();
}
- public Object remove(Object key) {
+ public V remove(Object key) {
throw new UnsupportedOperationException();
}
@@ -1207,20 +1210,20 @@
return m.size();
}
- public Collection values() {
- return new UnmodifiableCollection(m.values());
+ public Collection<V> values() {
+ return new UnmodifiableCollection<V>(m.values());
}
- public String toString() {
- return m.toString();
- }
+ public String toString() {
+ return m.toString();
+ }
}
- private static class UnmodifiableSet extends UnmodifiableCollection
- implements Set {
+ private static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
+ implements Set<E> {
private static final long serialVersionUID = -9215047833775013803L;
- UnmodifiableSet(Set set) {
+ UnmodifiableSet(Set<E> set) {
super(set);
}
@@ -1233,75 +1236,75 @@
}
}
- private static class UnmodifiableSortedMap extends UnmodifiableMap
- implements SortedMap {
+ private static class UnmodifiableSortedMap<K, V> extends UnmodifiableMap<K, V>
+ implements SortedMap<K, V> {
private static final long serialVersionUID = -8806743815996713206L;
- private final SortedMap sm;
+ private final SortedMap<K, V> sm;
- UnmodifiableSortedMap(SortedMap map) {
+ UnmodifiableSortedMap(SortedMap<K, V> map) {
super(map);
sm = map;
}
- public Comparator comparator() {
+ public Comparator<? super K> comparator() {
return sm.comparator();
}
- public Object firstKey() {
+ public K firstKey() {
return sm.firstKey();
}
- public SortedMap headMap(Object before) {
- return new UnmodifiableSortedMap(sm.headMap(before));
+ public SortedMap<K, V> headMap(K before) {
+ return new UnmodifiableSortedMap<K, V>(sm.headMap(before));
}
- public Object lastKey() {
+ public K lastKey() {
return sm.lastKey();
}
- public SortedMap subMap(Object start, Object end) {
- return new UnmodifiableSortedMap(sm.subMap(start, end));
+ public SortedMap<K, V> subMap(K start, K end) {
+ return new UnmodifiableSortedMap<K, V>(sm.subMap(start, end));
}
- public SortedMap tailMap(Object after) {
- return new UnmodifiableSortedMap(sm.tailMap(after));
+ public SortedMap<K, V> tailMap(K after) {
+ return new UnmodifiableSortedMap<K, V>(sm.tailMap(after));
}
}
- private static class UnmodifiableSortedSet extends UnmodifiableSet
- implements SortedSet {
+ private static class UnmodifiableSortedSet<E> extends UnmodifiableSet<E>
+ implements SortedSet<E> {
private static final long serialVersionUID = -4929149591599911165L;
- private final SortedSet ss;
+ private final SortedSet<E> ss;
- UnmodifiableSortedSet(SortedSet set) {
+ UnmodifiableSortedSet(SortedSet<E> set) {
super(set);
ss = set;
}
- public Comparator comparator() {
+ public Comparator<? super E> comparator() {
return ss.comparator();
}
- public Object first() {
+ public E first() {
return ss.first();
}
- public SortedSet headSet(Object before) {
- return new UnmodifiableSortedSet(ss.headSet(before));
+ public SortedSet<E> headSet(E before) {
+ return new UnmodifiableSortedSet<E>(ss.headSet(before));
}
- public Object last() {
+ public E last() {
return ss.last();
}
- public SortedSet subSet(Object start, Object end) {
- return new UnmodifiableSortedSet(ss.subSet(start, end));
+ public SortedSet<E> subSet(E start, E end) {
+ return new UnmodifiableSortedSet<E>(ss.subSet(start, end));
}
- public SortedSet tailSet(Object after) {
- return new UnmodifiableSortedSet(ss.tailSet(after));
+ public SortedSet<E> tailSet(E after) {
+ return new UnmodifiableSortedSet<E>(ss.tailSet(after));
}
}
@@ -1327,7 +1330,7 @@
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T object) {
if (list == null)
throw new NullPointerException();
- Comparable key = (Comparable) object;
+ Comparable key = (Comparable)object;
if (!(list instanceof RandomAccess)) {
ListIterator it = list.listIterator();
while (it.hasNext()) {
@@ -1414,12 +1417,12 @@
* when replacing an element in the destination list is not
* supported
*/
- public static void copy(List destination, List source) {
+ public static <T> void copy(List<? super T> destination, List<? extends T> source) {
if (destination.size() < source.size()) {
throw new ArrayIndexOutOfBoundsException();
}
- Iterator srcIt = source.iterator();
- ListIterator destIt = destination.listIterator();
+ Iterator<? extends T> srcIt = source.iterator();
+ ListIterator<? super T> destIt = destination.listIterator();
while (srcIt.hasNext()) {
try {
destIt.next();
@@ -1464,7 +1467,7 @@
* when replacing an element in the List is not supported
*/
public static <T> void fill(List<? super T> list, T object) {
- ListIterator it = list.listIterator();
+ ListIterator<? super T> it = list.listIterator();
while (it.hasNext()) {
it.next();
it.set(object);
@@ -1578,8 +1581,8 @@
* @exception IllegalArgumentException
* when <code>length < 0</code>
*/
- public static List nCopies(final int length, Object object) {
- return new CopiesList(length, object);
+ public static <T> List<T> nCopies(final int length, T object) {
+ return new CopiesList<T>(length, object);
}
/**
@@ -1592,7 +1595,7 @@
* @exception UnsupportedOperationException
* when replacing an element in the List is not supported
*/
- public static void reverse(List list) {
+ public static void reverse(List<?> list) {
int size = list.size();
ListIterator front = list.listIterator();
ListIterator back = list.listIterator(size);
@@ -1615,7 +1618,7 @@
* @see Comparable
* @see Serializable
*/
- public static Comparator reverseOrder() {
+ public static <T> Comparator<T> reverseOrder() {
return new ReverseComparator();
}
@@ -1637,7 +1640,7 @@
* @see Comparator
* @since 1.5
*/
- public static Comparator reverseOrder(Comparator c) {
+ public static <T> Comparator<T> reverseOrder(Comparator<T> c) {
if (c == null)
return reverseOrder();
return new ReverseComparatorWithComparator(c);
@@ -1652,7 +1655,7 @@
* @exception UnsupportedOperationException
* when replacing an element in the List is not supported
*/
- public static void shuffle(List list) {
+ public static void shuffle(List<?> list) {
shuffle(list, new Random());
}
@@ -1668,7 +1671,7 @@
* @exception UnsupportedOperationException
* when replacing an element in the List is not supported
*/
- public static void shuffle(List list, Random random) {
+ public static void shuffle(List<?> list, Random random) {
if (!(list instanceof RandomAccess)) {
Object[] array = list.toArray();
for (int i = array.length - 1; i > 0; i--) {
@@ -1687,11 +1690,12 @@
it.set(array[i++]);
}
} else {
- for (int i = list.size() - 1; i > 0; i--) {
+ List rawList = list;
+ for (int i = rawList.size() - 1; i > 0; i--) {
int index = random.nextInt() % (i + 1);
if (index < 0)
index = -index;
- list.set(index, list.set(i, list.get(index)));
+ rawList.set(index, rawList.set(i, rawList.get(index)));
}
}
}
@@ -1704,8 +1708,8 @@
* the element
* @return a Set containing the element
*/
- public static Set singleton(Object object) {
- return new SingletonSet(object);
+ public static <E> Set<E> singleton(E object) {
+ return new SingletonSet<E>(object);
}
/**
@@ -1716,8 +1720,8 @@
* the element
* @return a List containing the element
*/
- public static List singletonList(Object object) {
- return new SingletonList(object);
+ public static <E> List<E> singletonList(E object) {
+ return new SingletonList<E>(object);
}
/**
@@ -1730,8 +1734,8 @@
* the value
* @return a Map containing the key and value
*/
- public static Map singletonMap(Object key, Object value) {
- return new SingletonMap(key, value);
+ public static <K, V> Map<K, V> singletonMap(K key, V value) {
+ return new SingletonMap<K, V>(key, value);
}
/**
@@ -1744,14 +1748,14 @@
* when an element in the List does not implement Comparable
* or elements cannot be compared to each other
*/
- public static void sort(List list) {
+ public static <T extends Comparable<? super T>> void sort(List<T> list) {
Object[] array = list.toArray();
Arrays.sort(array);
int i = 0;
- ListIterator it = list.listIterator();
+ ListIterator<T> it = list.listIterator();
while (it.hasNext()) {
it.next();
- it.set(array[i++]);
+ it.set((T)array[i++]);
}
}
@@ -1767,14 +1771,14 @@
* when elements in the List cannot be compared to each other
* using the Comparator
*/
- public static void sort(List list, Comparator comparator) {
+ public static <T> void sort(List<T> list, Comparator<? super T> comparator) {
Object[] array = list.toArray();
- Arrays.sort(array, comparator);
+ Arrays.sort(array, (Comparator<Object>)comparator);
int i = 0;
- ListIterator it = list.listIterator();
+ ListIterator<T> it = list.listIterator();
while (it.hasNext()) {
it.next();
- it.set(array[i++]);
+ it.set((T)array[i++]);
}
}
@@ -1793,12 +1797,13 @@
* @exception IndexOutOfBoundsException
* if index1 or index2 is out of range of this list
*/
- public static void swap(List list, int index1, int index2) {
+ public static void swap(List<?> list, int index1, int index2) {
if (list == null)
throw new NullPointerException();
if (index1 == index2)
return;
- list.set(index2, list.set(index1, list.get(index2)));
+ List rawList = list;
+ rawList.set(index2, rawList.set(index1, rawList.get(index2)));
}
/**
@@ -1820,7 +1825,7 @@
* @exception UnsupportedOperationException
* if the list does not support setting elements
*/
- public static boolean replaceAll(List list, Object obj, Object obj2) {
+ public static <T> boolean replaceAll(List<T> list, T obj, T obj2) {
int index;
boolean found = false;
@@ -1843,7 +1848,8 @@
* It can be any integer: 0, positive, negative, larger than the
* list size
*/
- public static void rotate(List list, int dist) {
+ public static void rotate(List<?> lst, int dist) {
+ List list = lst;
int size = list.size();
// Can't sensibly rotate an empty collection
@@ -1898,7 +1904,7 @@
* @return the beginning index of the first occurrence of
* <code>sublist</code> in <code>list</code>, or -1
*/
- public static int indexOfSubList(List list, List sublist) {
+ public static int indexOfSubList(List<?> list, List<?> sublist) {
int size = list.size();
int sublistSize = sublist.size();
@@ -1963,7 +1969,7 @@
* @return the beginning index of the last occurrence of <code>sublist</code>
* in <code>list</code>, or -1
*/
- public static int lastIndexOfSubList(List list, List sublist) {
+ public static int lastIndexOfSubList(List<?> list, List<?> sublist) {
int sublistSize = sublist.size();
int size = list.size();
@@ -2020,8 +2026,8 @@
* Enumeration
* @return and ArrayList
*/
- public static ArrayList list(Enumeration enumeration) {
- ArrayList list = new ArrayList();
+ public static <T> ArrayList<T> list(Enumeration<T> enumeration) {
+ ArrayList<T> list = new ArrayList<T>();
while (enumeration.hasMoreElements()) {
list.add(enumeration.nextElement());
}
@@ -2036,10 +2042,10 @@
* the Collection
* @return a synchronized Collection
*/
- public static Collection synchronizedCollection(Collection collection) {
+ public static <T> Collection<T> synchronizedCollection(Collection<T> collection) {
if (collection == null)
throw new NullPointerException();
- return new SynchronizedCollection(collection);
+ return new SynchronizedCollection<T>(collection);
}
/**
@@ -2050,13 +2056,13 @@
* the List
* @return a synchronized List
*/
- public static List synchronizedList(List list) {
+ public static <T> List<T> synchronizedList(List<T> list) {
if (list == null)
throw new NullPointerException();
if (list instanceof RandomAccess)
- return new SynchronizedRandomAccessList(list);
+ return new SynchronizedRandomAccessList<T>(list);
else
- return new SynchronizedList(list);
+ return new SynchronizedList<T>(list);
}
/**
@@ -2067,10 +2073,10 @@
* the Map
* @return a synchronized Map
*/
- public static Map synchronizedMap(Map map) {
+ public static <K, V> Map<K, V> synchronizedMap(Map<K, V> map) {
if (map == null)
throw new NullPointerException();
- return new SynchronizedMap(map);
+ return new SynchronizedMap<K, V>(map);
}
/**
@@ -2081,10 +2087,10 @@
* the Set
* @return a synchronized Set
*/
- public static Set synchronizedSet(Set set) {
+ public static <E> Set<E> synchronizedSet(Set<E> set) {
if (set == null)
throw new NullPointerException();
- return new SynchronizedSet(set);
+ return new SynchronizedSet<E>(set);
}
/**
@@ -2095,10 +2101,10 @@
* the SortedMap
* @return a synchronized SortedMap
*/
- public static SortedMap synchronizedSortedMap(SortedMap map) {
+ public static <K, V> SortedMap<K, V> synchronizedSortedMap(SortedMap<K, V> map) {
if (map == null)
throw new NullPointerException();
- return new SynchronizedSortedMap(map);
+ return new SynchronizedSortedMap<K, V>(map);
}
/**
@@ -2109,10 +2115,10 @@
* the SortedSet
* @return a synchronized SortedSet
*/
- public static SortedSet synchronizedSortedSet(SortedSet set) {
+ public static <E> SortedSet<E> synchronizedSortedSet(SortedSet<E> set) {
if (set == null)
throw new NullPointerException();
- return new SynchronizedSortedSet(set);
+ return new SynchronizedSortedSet<E>(set);
}
/**
@@ -2124,10 +2130,10 @@
* the Collection
* @return an unmodifiable Collection
*/
- public static Collection unmodifiableCollection(Collection collection) {
+ public static <E> Collection<E> unmodifiableCollection(Collection<E> collection) {
if (collection == null)
throw new NullPointerException();
- return new UnmodifiableCollection(collection);
+ return new UnmodifiableCollection<E>(collection);
}
/**
@@ -2139,13 +2145,13 @@
* the List
* @return an unmodifiable List
*/
- public static List unmodifiableList(List list) {
+ public static <E> List<E> unmodifiableList(List<E> list) {
if (list == null)
throw new NullPointerException();
if (list instanceof RandomAccess)
- return new UnmodifiableRandomAccessList(list);
+ return new UnmodifiableRandomAccessList<E>(list);
else
- return new UnmodifiableList(list);
+ return new UnmodifiableList<E>(list);
}
/**
@@ -2157,10 +2163,10 @@
* the Map
* @return a unmodifiable Map
*/
- public static Map unmodifiableMap(Map map) {
+ public static <K, V> Map<K, V> unmodifiableMap(Map<K, V> map) {
if (map == null)
throw new NullPointerException();
- return new UnmodifiableMap(map);
+ return new UnmodifiableMap<K, V>(map);
}
/**
@@ -2172,10 +2178,10 @@
* the Set
* @return a unmodifiable Set
*/
- public static Set unmodifiableSet(Set set) {
+ public static <E> Set<E> unmodifiableSet(Set<E> set) {
if (set == null)
throw new NullPointerException();
- return new UnmodifiableSet(set);
+ return new UnmodifiableSet<E>(set);
}
/**
@@ -2187,10 +2193,10 @@
* the SortedMap
* @return a unmodifiable SortedMap
*/
- public static SortedMap unmodifiableSortedMap(SortedMap map) {
+ public static <K, V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, V> map) {
if (map == null)
throw new NullPointerException();
- return new UnmodifiableSortedMap(map);
+ return new UnmodifiableSortedMap<K, V>(map);
}
/**
@@ -2202,10 +2208,10 @@
* the SortedSet
* @return a unmodifiable SortedSet
*/
- public static SortedSet unmodifiableSortedSet(SortedSet set) {
+ public static <E> SortedSet<E> unmodifiableSortedSet(SortedSet<E> set) {
if (set == null)
throw new NullPointerException();
- return new UnmodifiableSortedSet(set);
+ return new UnmodifiableSortedSet<E>(set);
}
/**
@@ -2224,7 +2230,7 @@
*
* @since 1.5
*/
- public static int frequency(Collection c, Object o) {
+ public static int frequency(Collection<?> c, Object o) {
if (c == null)
throw new NullPointerException();
if (c.isEmpty())
@@ -2277,7 +2283,7 @@
*
* @return a typesafe collection
*/
- public static Collection checkedCollection(Collection c, Class type) {
+ public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type) {
return new CheckedCollection(c, type);
}
@@ -2289,7 +2295,7 @@
*
* @return a typesafe map
*/
- public static Map checkedMap(Map m, Class keyType, Class valueType) {
+ public static <K, V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType) {
return new CheckedMap(m, keyType, valueType);
}
@@ -2301,7 +2307,7 @@
*
* @return a typesafe list
*/
- public static List checkedList(List list, Class type) {
+ public static <E> List<E> checkedList(List<E> list, Class<E> type) {
if (list instanceof RandomAccess) {
return new CheckedRandomAccessList(list, type);
} else {
@@ -2317,7 +2323,7 @@
*
* @return a typesafe set
*/
- public static Set checkedSet(Set s, Class type) {
+ public static <E> Set<E> checkedSet(Set<E> s, Class<E> type) {
return new CheckedSet(s, type);
}
@@ -2329,8 +2335,8 @@
*
* @return a typesafe sorted map
*/
- public static SortedMap checkedSortedMap(SortedMap m, Class keyType,
- Class valueType) {
+ public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, Class<K> keyType,
+ Class<V> valueType) {
return new CheckedSortedMap(m, keyType, valueType);
}
@@ -2342,7 +2348,7 @@
*
* @return a typesafe sorted set
*/
- public static SortedSet checkedSortedSet(SortedSet s, Class type) {
+ public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type) {
return new CheckedSortedSet(s, type);
}
@@ -2377,7 +2383,7 @@
*
* @exception NullPointerException if one of the collections is null
*/
- public static boolean disjoint(Collection c1, Collection c2) {
+ public static boolean disjoint(Collection<?> c1, Collection<?> c2) {
if ((c1 instanceof Set) && !(c2 instanceof Set)
|| (c2.size()) > c1.size()) {
Collection tmp = c1;