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

equal deleted inserted replaced

-:92676a77a667
+:b95438b17098
 implements Map<K,V>, Cloneable, java.io.Serializable {
 /**
 * The hash table data.
 */
-private transient Entry[] table;
+private transient Entry<?,?>[] table;
 /**
 * The total number of entries in the hash table.
 */
 private transient int count;
 throw new IllegalArgumentException("Illegal Load: "+loadFactor);
 if (initialCapacity==0)
 initialCapacity = 1;
 this.loadFactor = loadFactor;
-table = new Entry[initialCapacity];
+table = new Entry<?,?>[initialCapacity];
 threshold = (int)(initialCapacity * loadFactor);
 }
 /**
 * Constructs a new, empty hashtable with the specified initial capacity
 public synchronized boolean contains(Object value) {
 if (value == null) {
 throw new NullPointerException();
 }
-Entry tab[] = table;
+Entry<?,?> tab[] = table;
 for (int i = tab.length ; i-- > 0 ;) {
-for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {
+for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) {
 if (e.value.equals(value)) {
 return true;
 }
 }
 }
 *          <tt>equals</tt> method; <code>false</code> otherwise.
 * @throws  NullPointerException  if the key is <code>null</code>
 * @see     #contains(Object)
 */
 public synchronized boolean containsKey(Object key) {
-Entry tab[] = table;
+Entry<?,?> tab[] = table;
 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;
-for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
+for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
 if ((e.hash == hash) && e.key.equals(key)) {
 return true;
 }
 }
 return false;
 * @return the value to which the specified key is mapped, or
 *         {@code null} if this map contains no mapping for the key
 * @throws NullPointerException if the specified key is null
 * @see     #put(Object, Object)
 */
+@SuppressWarnings("unchecked")
 public synchronized V get(Object key) {
-Entry tab[] = table;
+Entry<?,?> tab[] = table;
 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;
-for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
+for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
 if ((e.hash == hash) && e.key.equals(key)) {
-return e.value;
+return (V)e.value;
 }
 }
 return null;
 }
 * hashtable, in order to accommodate and access its entries more
 * efficiently.  This method is called automatically when the
 * number of keys in the hashtable exceeds this hashtable's capacity
 * and load factor.
 */
+@SuppressWarnings("unchecked")
 protected void rehash() {
 int oldCapacity = table.length;
-Entry[] oldMap = table;
+Entry<?,?>[] oldMap = table;
 // overflow-conscious code
 int newCapacity = (oldCapacity << 1) + 1;
 if (newCapacity - MAX_ARRAY_SIZE > 0) {
 if (oldCapacity == MAX_ARRAY_SIZE)
 // Keep running with MAX_ARRAY_SIZE buckets
 return;
 newCapacity = MAX_ARRAY_SIZE;
 }
-Entry[] newMap = new Entry[newCapacity];
+Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
 modCount++;
 threshold = (int)(newCapacity * loadFactor);
 table = newMap;
 for (int i = oldCapacity ; i-- > 0 ;) {
-for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
+for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
 Entry<K,V> e = old;
 old = old.next;
 int index = (e.hash & 0x7FFFFFFF) % newCapacity;
-e.next = newMap[index];
+e.next = (Entry<K,V>)newMap[index];
 newMap[index] = e;
 }
 }
 }
 if (value == null) {
 throw new NullPointerException();
 }
 // Makes sure the key is not already in the hashtable.
-Entry tab[] = table;
+Entry<?,?> tab[] = table;
 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;
-for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
+@SuppressWarnings("unchecked")
-if ((e.hash == hash) && e.key.equals(key)) {
+Entry<K,V> entry = (Entry<K,V>)tab[index];
-V old = e.value;
+for(; entry != null ; entry = entry.next) {
-e.value = value;
+if ((entry.hash == hash) && entry.key.equals(key)) {
+V old = entry.value;
+entry.value = value;
 return old;
 }
 }
 modCount++;
 tab = table;
 index = (hash & 0x7FFFFFFF) % tab.length;
 }
 // Creates the new entry.
-Entry<K,V> e = tab[index];
+@SuppressWarnings("unchecked")
+Entry<K,V> e = (Entry<K,V>)tab[index];
 tab[index] = new Entry<>(hash, key, value, e);
 count++;
 return null;
 }
 * @return  the value to which the key had been mapped in this hashtable,
 *          or <code>null</code> if the key did not have a mapping
 * @throws  NullPointerException  if the key is <code>null</code>
 */
 public synchronized V remove(Object key) {
-Entry tab[] = table;
+Entry<?,?> tab[] = table;
 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;
-for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {
+@SuppressWarnings("unchecked")
+Entry<K,V> e = (Entry<K,V>)tab[index];
+for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
 if ((e.hash == hash) && e.key.equals(key)) {
 modCount++;
 if (prev != null) {
 prev.next = e.next;
 } else {
 /**
 * Clears this hashtable so that it contains no keys.
 */
 public synchronized void clear() {
-Entry tab[] = table;
+Entry<?,?> tab[] = table;
 modCount++;
 for (int index = tab.length; --index >= 0; )
 tab[index] = null;
 count = 0;
 }
 *
 * @return  a clone of the hashtable
 */
 public synchronized Object clone() {
 try {
-Hashtable<K,V> t = (Hashtable<K,V>) super.clone();
+Hashtable<?,?> t = (Hashtable<?,?>)super.clone();
-t.table = new Entry[table.length];
+t.table = new Entry<?,?>[table.length];
 for (int i = table.length ; i-- > 0 ; ) {
 t.table[i] = (table[i] != null)
-? (Entry<K,V>) table[i].clone() : null;
+? (Entry<?,?>) table[i].clone() : null;
 }
 t.keySet = null;
 t.entrySet = null;
 t.values = null;
 t.modCount = 0;
 }
 public boolean contains(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
-Map.Entry entry = (Map.Entry)o;
+Map.Entry<?,?> entry = (Map.Entry<?,?>)o;
 Object key = entry.getKey();
-Entry[] tab = table;
+Entry<?,?>[] tab = table;
 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;
-for (Entry e = tab[index]; e != null; e = e.next)
+for (Entry<?,?> e = tab[index]; e != null; e = e.next)
 if (e.hash==hash && e.equals(entry))
 return true;
 return false;
 }
 public boolean remove(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
-Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
+Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
-K key = entry.getKey();
+Object key = entry.getKey();
-Entry[] tab = table;
+Entry<?,?>[] tab = table;
 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;
-for (Entry<K,V> e = tab[index], prev = null; e != null;
+@SuppressWarnings("unchecked")
-prev = e, e = e.next) {
+Entry<K,V> e = (Entry<K,V>)tab[index];
+for(Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
 if (e.hash==hash && e.equals(entry)) {
 modCount++;
 if (prev != null)
 prev.next = e.next;
 else
 if (o == this)
 return true;
 if (!(o instanceof Map))
 return false;
-Map<K,V> t = (Map<K,V>) o;
+Map<?,?> t = (Map<?,?>) o;
 if (t.size() != size())
 return false;
 try {
 Iterator<Map.Entry<K,V>> i = entrySet().iterator();
 int h = 0;
 if (count == 0 || loadFactor < 0)
 return h;  // Returns zero
 loadFactor = -loadFactor;  // Mark hashCode computation in progress
-Entry[] tab = table;
+Entry<?,?>[] tab = table;
 for (int i = 0; i < tab.length; i++)
-for (Entry e = tab[i]; e != null; e = e.next)
+for (Entry<?,?> e = tab[i]; e != null; e = e.next)
 h += e.key.hashCode() ^ e.value.hashCode();
 loadFactor = -loadFactor;  // Mark hashCode computation complete
 return h;
 }
 s.writeInt(table.length);
 s.writeInt(count);
 // Stack copies of the entries in the table
 for (int index = 0; index < table.length; index++) {
-Entry entry = table[index];
+Entry<?,?> entry = table[index];
 while (entry != null) {
 entryStack =
 new Entry<>(0, entry.key, entry.value, entryStack);
 entry = entry.next;
 int length = (int)(elements * loadFactor) + (elements / 20) + 3;
 if (length > elements && (length & 1) == 0)
 length--;
 if (origlength > 0 && length > origlength)
 length = origlength;
+Entry<?,?>[] table = new Entry<?,?>[length];
-Entry[] table = new Entry[length];
 count = 0;
 // Read the number of elements and then all the key/value objects
 for (; elements > 0; elements--) {
-K key = (K)s.readObject();
+@SuppressWarnings("unchecked")
-V value = (V)s.readObject();
+K key = (K)s.readObject();
+@SuppressWarnings("unchecked")
+V value = (V)s.readObject();
 // synch could be eliminated for performance
 reconstitutionPut(table, key, value);
 }
 this.table = table;
 }
 * checking for rehashing is necessary since the number of elements
 * initially in the table is known. The modCount is not incremented
 * because we are creating a new instance. Also, no return value
 * is needed.
 */
-private void reconstitutionPut(Entry[] tab, K key, V value)
+private void reconstitutionPut(Entry<?,?>[] tab, K key, V value)
 throws StreamCorruptedException
 {
 if (value == null) {
 throw new java.io.StreamCorruptedException();
 }
 // Makes sure the key is not already in the hashtable.
 // This should not happen in deserialized version.
 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;
-for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
+for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
 if ((e.hash == hash) && e.key.equals(key)) {
 throw new java.io.StreamCorruptedException();
 }
 }
 // Creates the new entry.
-Entry<K,V> e = tab[index];
+@SuppressWarnings("unchecked")
+Entry<K,V> e = (Entry<K,V>)tab[index];
 tab[index] = new Entry<>(hash, key, value, e);
 count++;
 }
 /**
 this.key = key;
 this.value = value;
 this.next = next;
 }
+@SuppressWarnings("unchecked")
 protected Object clone() {
 return new Entry<>(hash, key, value,
 (next==null ? null : (Entry<K,V>) next.clone()));
 }
 }
 public boolean equals(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
-Map.Entry e = (Map.Entry)o;
+Map.Entry<?,?> e = (Map.Entry<?,?>)o;
 return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
 (value==null ? e.getValue()==null : value.equals(e.getValue()));
 }
 * can be created with the Iterator methods disabled.  This is necessary
 * to avoid unintentionally increasing the capabilities granted a user
 * by passing an Enumeration.
 */
 private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
-Entry[] table = Hashtable.this.table;
+Entry<?,?>[] table = Hashtable.this.table;
 int index = table.length;
-Entry<K,V> entry = null;
+Entry<?,?> entry = null;
-Entry<K,V> lastReturned = null;
+Entry<?,?> lastReturned = null;
 int type;
 /**
 * Indicates whether this Enumerator is serving as an Iterator
 * or an Enumeration.  (true -> Iterator).
 this.type = type;
 this.iterator = iterator;
 }
 public boolean hasMoreElements() {
-Entry<K,V> e = entry;
+Entry<?,?> e = entry;
 int i = index;
-Entry[] t = table;
+Entry<?,?>[] t = table;
 /* Use locals for faster loop iteration */
 while (e == null && i > 0) {
 e = t[--i];
 }
 entry = e;
 index = i;
 return e != null;
 }
+@SuppressWarnings("unchecked")
 public T nextElement() {
-Entry<K,V> et = entry;
+Entry<?,?> et = entry;
 int i = index;
-Entry[] t = table;
+Entry<?,?>[] t = table;
 /* Use locals for faster loop iteration */
 while (et == null && i > 0) {
 et = t[--i];
 }
 entry = et;
 index = i;
 if (et != null) {
-Entry<K,V> e = lastReturned = entry;
+Entry<?,?> e = lastReturned = entry;
 entry = e.next;
 return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
 }
 throw new NoSuchElementException("Hashtable Enumerator");
 }
 throw new IllegalStateException("Hashtable Enumerator");
 if (modCount != expectedModCount)
 throw new ConcurrentModificationException();
 synchronized(Hashtable.this) {
-Entry[] tab = Hashtable.this.table;
+Entry<?,?>[] tab = Hashtable.this.table;
 int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;
-for (Entry<K,V> e = tab[index], prev = null; e != null;
+@SuppressWarnings("unchecked")
-prev = e, e = e.next) {
+Entry<K,V> e = (Entry<K,V>)tab[index];
+for(Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
 if (e == lastReturned) {
 modCount++;
 expectedModCount++;
 if (prev == null)
 tab[index] = e.next;

changeset 12448	b95438b17098
parent 10419	12c063b39232
child 12859	c44b88bb9b5e