Java tutorial
/* * Copyright 2006 Brian S O'Neill * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ //revised from cojen import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; import java.lang.ref.WeakReference; import java.util.AbstractCollection; import java.util.AbstractMap; import java.util.AbstractSet; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.ConcurrentModificationException; import java.util.Iterator; import java.util.Map; import java.util.NoSuchElementException; import java.util.Set; //revised from cojen /** * A Map that weakly references its values and can be used as a simple cache. * WeakValuedHashMap is not thread-safe and must be wrapped with * Collections.synchronizedMap to be made thread-safe. * <p> * Note: Weakly referenced entries may be automatically removed during * either accessor or mutator operations, possibly causing a concurrent * modification to be detected. Therefore, even if multiple threads are only * accessing this map, be sure to synchronize this map first. Also, do not * rely on the value returned by size() when using an iterator from this map. * The iterators may return less entries than the amount reported by size(). * * @author Brian S O'Neill * @since 2.1 */ public class WeakValuedHashMap<K, V> extends ReferencedValueHashMap<K, V> { /** * Constructs a new, empty map with the specified initial * capacity and the specified load factor. * * @param initialCapacity the initial capacity of the HashMap. * @param loadFactor the load factor of the HashMap * @throws IllegalArgumentException if the initial capacity is less * than zero, or if the load factor is nonpositive. */ public WeakValuedHashMap(int initialCapacity, float loadFactor) { super(initialCapacity, loadFactor); } /** * Constructs a new, empty map with the specified initial capacity * and default load factor, which is <tt>0.75</tt>. * * @param initialCapacity the initial capacity of the HashMap. * @throws IllegalArgumentException if the initial capacity is less * than zero. */ public WeakValuedHashMap(int initialCapacity) { super(initialCapacity); } /** * Constructs a new, empty map with a default capacity and load * factor, which is <tt>0.75</tt>. */ public WeakValuedHashMap() { super(); } /** * Constructs a new map with the same mappings as the given map. The * map is created with a capacity of twice the number of mappings in * the given map or 11 (whichever is greater), and a default load factor, * which is <tt>0.75</tt>. */ public WeakValuedHashMap(Map<? extends K, ? extends V> t) { super(t); } Entry<K, V> newEntry(int hash, K key, V value, Entry<K, V> next) { return new WeakEntry<K, V>(hash, key, value, next); } static class WeakEntry<K, V> extends ReferencedValueHashMap.Entry<K, V> { WeakEntry(int hash, K key, V value, Entry<K, V> next) { super(hash, key, value, next); } WeakEntry(int hash, K key, Reference<V> value, Entry<K, V> next) { super(hash, key, value, next); } Entry newEntry(int hash, K key, Reference<V> value, Entry<K, V> next) { return new WeakEntry<K, V>(hash, key, value, next); } Reference<V> newReference(V value) { return new WeakReference<V>(value); } } } /** * A Map that references its values and can be used as a simple cache. * Instances are not thread-safe and must be wrapped with * Collections.synchronizedMap to be made thread-safe. * <p> * Note: Referenced entries may be automatically removed during * either accessor or mutator operations, possibly causing a concurrent * modification to be detected. Therefore, even if multiple threads are only * accessing this map, be sure to synchronize this map first. Also, do not * rely on the value returned by size() when using an iterator from this map. * The iterators may return less entries than the amount reported by size(). * * @author Brian S O'Neill */ abstract class ReferencedValueHashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable { private transient Entry<K, V>[] table; private transient int count; private int threshold; private final float loadFactor; private transient volatile int modCount; // Views private transient Set<K> keySet; private transient Set<Map.Entry<K, V>> entrySet; private transient Collection<V> values; /** * Constructs a new, empty map with the specified initial * capacity and the specified load factor. * * @param initialCapacity the initial capacity of the HashMap. * @param loadFactor the load factor of the HashMap * @throws IllegalArgumentException if the initial capacity is less * than zero, or if the load factor is nonpositive. */ public ReferencedValueHashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) { throw new IllegalArgumentException("Illegal Initial Capacity: " + initialCapacity); } if (loadFactor <= 0 || Float.isNaN(loadFactor)) { throw new IllegalArgumentException("Illegal Load factor: " + loadFactor); } if (initialCapacity == 0) { initialCapacity = 1; } this.loadFactor = loadFactor; this.table = new Entry[initialCapacity]; this.threshold = (int) (initialCapacity * loadFactor); } /** * Constructs a new, empty map with the specified initial capacity * and default load factor, which is <tt>0.75</tt>. * * @param initialCapacity the initial capacity of the HashMap. * @throws IllegalArgumentException if the initial capacity is less * than zero. */ public ReferencedValueHashMap(int initialCapacity) { this(initialCapacity, 0.75f); } /** * Constructs a new, empty map with a default capacity and load * factor, which is <tt>0.75</tt>. */ public ReferencedValueHashMap() { this(11, 0.75f); } /** * Constructs a new map with the same mappings as the given map. The * map is created with a capacity of twice the number of mappings in * the given map or 11 (whichever is greater), and a default load factor, * which is <tt>0.75</tt>. */ public ReferencedValueHashMap(Map<? extends K, ? extends V> t) { this(Math.max(2 * t.size(), 11), 0.75f); putAll(t); } public int size() { return this.count; } public boolean isEmpty() { return this.count == 0; } public boolean containsValue(Object value) { if (value == null) { value = KeyFactory.NULL; } Entry[] tab = this.table; for (int i = tab.length; i-- > 0;) { for (Entry e = tab[i], prev = null; e != null; e = e.next) { Object entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[i] = e.next; } this.count--; } else if (value.equals(entryValue)) { return true; } else { prev = e; } } } return false; } public boolean containsKey(Object key) { Entry<K, V>[] tab = this.table; if (key != null) { int hash = key.hashCode(); int index = (hash & 0x7fffffff) % tab.length; for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) { if (e.get() == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && key.equals(e.key)) { return true; } else { prev = e; } } } else { for (Entry<K, V> e = tab[0], prev = null; e != null; e = e.next) { if (e.get() == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[0] = e.next; } this.count--; } else if (e.key == null) { return true; } else { prev = e; } } } return false; } public V get(Object key) { Entry<K, V>[] tab = this.table; if (key != null) { int hash = key.hashCode(); int index = (hash & 0x7fffffff) % tab.length; for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) { V entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } count--; } else if (e.hash == hash && key.equals(e.key)) { return (entryValue == KeyFactory.NULL) ? null : entryValue; } else { prev = e; } } } else { for (Entry<K, V> e = tab[0], prev = null; e != null; e = e.next) { V entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[0] = e.next; } this.count--; } else if (e.key == null) { return (entryValue == KeyFactory.NULL) ? null : entryValue; } else { prev = e; } } } return null; } /** * Scans the contents of this map, removing all entries that have a * cleared soft value. */ private void cleanup() { Entry<K, V>[] tab = this.table; for (int i = tab.length; i-- > 0;) { for (Entry<K, V> e = tab[i], prev = null; e != null; e = e.next) { if (e.get() == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[i] = e.next; } this.count--; } else { prev = e; } } } } /** * Rehashes the contents of this map into a new <tt>HashMap</tt> instance * with a larger capacity. This method is called automatically when the * number of keys in this map exceeds its capacity and load factor. */ private void rehash() { int oldCapacity = this.table.length; Entry<K, V>[] oldMap = this.table; int newCapacity = oldCapacity * 2 + 1; Entry<K, V>[] newMap = new Entry[newCapacity]; this.modCount++; this.threshold = (int) (newCapacity * this.loadFactor); this.table = newMap; for (int i = oldCapacity; i-- > 0;) { for (Entry<K, V> old = oldMap[i]; old != null;) { Entry<K, V> e = old; old = old.next; // Only copy entry if its value hasn't been cleared. if (e.get() == null) { this.count--; } else { int index = (e.hash & 0x7fffffff) % newCapacity; e.next = newMap[index]; newMap[index] = e; } } } } public V put(K key, V value) { if (value == null) { value = (V) KeyFactory.NULL; } // Makes sure the key is not already in the HashMap. Entry<K, V>[] tab = this.table; int hash; int index; if (key != null) { hash = key.hashCode(); index = (hash & 0x7fffffff) % tab.length; for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) { V entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && key.equals(e.key)) { e.setValue(value); return (entryValue == KeyFactory.NULL) ? null : entryValue; } else { prev = e; } } } else { hash = 0; index = 0; for (Entry<K, V> e = tab[0], prev = null; e != null; e = e.next) { V entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[0] = e.next; } this.count--; } else if (e.key == null) { e.setValue(value); return (entryValue == KeyFactory.NULL) ? null : entryValue; } else { prev = e; } } } this.modCount++; if (this.count >= this.threshold) { // Cleanup the table if the threshold is exceeded. cleanup(); } if (this.count >= this.threshold) { // Rehash the table if the threshold is still exceeded. rehash(); tab = this.table; index = (hash & 0x7fffffff) % tab.length; } // Creates the new entry. Entry<K, V> e = newEntry(hash, key, (V) value, tab[index]); tab[index] = e; this.count++; return null; } public V remove(Object key) { Entry<K, V>[] tab = this.table; if (key != null) { int hash = key.hashCode(); int index = (hash & 0x7fffffff) % tab.length; for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) { V entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && key.equals(e.key)) { this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; e.setValue(null); return (entryValue == KeyFactory.NULL) ? null : entryValue; } else { prev = e; } } } else { for (Entry<K, V> e = tab[0], prev = null; e != null; e = e.next) { V entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[0] = e.next; } this.count--; } else if (e.key == null) { this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[0] = e.next; } this.count--; e.setValue(null); return (entryValue == KeyFactory.NULL) ? null : entryValue; } else { prev = e; } } } return null; } public void putAll(Map<? extends K, ? extends V> t) { Iterator i = t.entrySet().iterator(); while (i.hasNext()) { Map.Entry<K, V> e = (Map.Entry<K, V>) i.next(); put(e.getKey(), e.getValue()); } } public void clear() { Entry[] tab = this.table; this.modCount++; for (int index = tab.length; --index >= 0;) { tab[index] = null; } this.count = 0; } public Object clone() { try { ReferencedValueHashMap t = (ReferencedValueHashMap) super.clone(); t.table = new Entry[this.table.length]; for (int i = this.table.length; i-- > 0;) { t.table[i] = (this.table[i] != null) ? (Entry) this.table[i].clone() : null; } t.keySet = null; t.entrySet = null; t.values = null; t.modCount = 0; return t; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); } } public Set<K> keySet() { if (this.keySet == null) { this.keySet = new AbstractSet<K>() { public Iterator iterator() { return createHashIterator(WeakIdentityMap.KEYS); } public int size() { return ReferencedValueHashMap.this.count; } public boolean contains(Object o) { return containsKey(o); } public boolean remove(Object o) { if (o == null) { if (ReferencedValueHashMap.this.containsKey(null)) { ReferencedValueHashMap.this.remove(null); return true; } else { return false; } } else { return ReferencedValueHashMap.this.remove(o) != null; } } public void clear() { ReferencedValueHashMap.this.clear(); } public String toString() { return WeakIdentityMap.toString(this); } }; } return this.keySet; } public Collection<V> values() { if (this.values == null) { this.values = new AbstractCollection<V>() { public Iterator iterator() { return createHashIterator(WeakIdentityMap.VALUES); } public int size() { return ReferencedValueHashMap.this.count; } public boolean contains(Object o) { return containsValue(o); } public void clear() { ReferencedValueHashMap.this.clear(); } public String toString() { return WeakIdentityMap.toString(this); } }; } return this.values; } public Set<Map.Entry<K, V>> entrySet() { if (this.entrySet == null) { this.entrySet = new AbstractSet<Map.Entry<K, V>>() { public Iterator iterator() { return createHashIterator(WeakIdentityMap.ENTRIES); } public boolean contains(Object o) { if (!(o instanceof Map.Entry)) { return false; } Map.Entry entry = (Map.Entry) o; Object key = entry.getKey(); Entry[] tab = ReferencedValueHashMap.this.table; int hash = key == null ? 0 : key.hashCode(); int index = (hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { Object entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. ReferencedValueHashMap.this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } ReferencedValueHashMap.this.count--; } else if (e.hash == hash && e.equals(entry)) { return true; } else { prev = e; } } return false; } public boolean remove(Object o) { if (!(o instanceof Map.Entry)) { return false; } Map.Entry entry = (Map.Entry) o; Object key = entry.getKey(); Entry[] tab = ReferencedValueHashMap.this.table; int hash = key == null ? 0 : key.hashCode(); int index = (hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { Object entryValue = e.get(); if (entryValue == null) { // Clean up after a cleared Reference. ReferencedValueHashMap.this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } ReferencedValueHashMap.this.count--; } else if (e.hash == hash && e.equals(entry)) { ReferencedValueHashMap.this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } ReferencedValueHashMap.this.count--; e.setValue(null); return true; } else { prev = e; } } return false; } public int size() { return ReferencedValueHashMap.this.count; } public void clear() { ReferencedValueHashMap.this.clear(); } public String toString() { return WeakIdentityMap.toString(this); } }; } return this.entrySet; } public String toString() { // Cleanup stale entries first, so as not to allocate a larger than // necessary StringBuffer. cleanup(); return WeakIdentityMap.toString(this); } abstract Entry<K, V> newEntry(int hash, K key, V value, Entry<K, V> next); private Iterator createHashIterator(int type) { if (this.count == 0) { return Collections.EMPTY_SET.iterator(); } else { return new HashIterator(type); } } /** * Collision list entry. */ abstract static class Entry<K, V> implements Map.Entry<K, V> { int hash; K key; Entry<K, V> next; private Reference<V> value; Entry(int hash, K key, V value, Entry<K, V> next) { this.hash = hash; this.key = key; this.value = newReference(value); this.next = next; } Entry(int hash, K key, Reference<V> value, Entry<K, V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } // Map.Entry Ops public K getKey() { return this.key; } public V getValue() { V value = this.value.get(); return value == KeyFactory.NULL ? null : value; } public V setValue(V value) { V oldValue = getValue(); this.value = newReference(value == null ? ((V) KeyFactory.NULL) : value); return oldValue; } public boolean equals(Object obj) { if (!(obj instanceof Map.Entry)) { return false; } return equals((Map.Entry) obj); } boolean equals(Map.Entry e) { Object thisValue = get(); if (thisValue == null) { return false; } else if (thisValue == KeyFactory.NULL) { thisValue = null; } return (this.key == null ? e.getKey() == null : this.key.equals(e.getKey())) && (thisValue == null ? e.getValue() == null : thisValue.equals(e.getValue())); } public int hashCode() { return this.hash ^ get().hashCode(); } public String toString() { return this.key + "=" + getValue(); } protected Object clone() { return newEntry(this.hash, this.key, (Reference) this.value, (this.next == null ? null : (Entry) this.next.clone())); } abstract Entry newEntry(int hash, K key, Reference<V> value, Entry<K, V> next); abstract Reference<V> newReference(V value); // Like getValue(), except does not convert NULL to null. V get() { return this.value.get(); } } private class HashIterator implements Iterator { private final int type; private final Entry[] table; private int index; // To ensure that the iterator doesn't return cleared entries, keep a // hard reference to the value. Its existence will prevent the soft // value from being cleared. private Object entryValue; private Entry entry; private Entry last; /** * The modCount value that the iterator believes that the backing * List should have. If this expectation is violated, the iterator * has detected concurrent modification. */ private int expectedModCount = ReferencedValueHashMap.this.modCount; HashIterator(int type) { this.table = ReferencedValueHashMap.this.table; this.type = type; this.index = table.length; } public boolean hasNext() { while (this.entry == null || (this.entryValue = this.entry.get()) == null) { if (this.entry != null) { // Clean up after a cleared Reference. remove(this.entry); this.entry = this.entry.next; } if (this.entry == null) { if (this.index <= 0) { return false; } else { this.entry = this.table[--this.index]; } } } return true; } public Object next() { if (ReferencedValueHashMap.this.modCount != expectedModCount) { throw new ConcurrentModificationException(); } if (!hasNext()) { throw new NoSuchElementException(); } this.last = this.entry; this.entry = this.entry.next; return this.type == WeakIdentityMap.KEYS ? this.last.getKey() : (this.type == WeakIdentityMap.VALUES ? this.last.getValue() : this.last); } public void remove() { if (this.last == null) { throw new IllegalStateException(); } if (ReferencedValueHashMap.this.modCount != expectedModCount) { throw new ConcurrentModificationException(); } remove(this.last); this.last = null; } private void remove(Entry toRemove) { Entry[] tab = this.table; int index = (toRemove.hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { if (e == toRemove) { ReferencedValueHashMap.this.modCount++; expectedModCount++; if (prev == null) { tab[index] = e.next; } else { prev.next = e.next; } ReferencedValueHashMap.this.count--; return; } else { prev = e; } } throw new ConcurrentModificationException(); } } } class WeakIdentityMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable { // Types of Iterators static final int KEYS = 0; static final int VALUES = 1; static final int ENTRIES = 2; /** * Converts a collection to string, supporting collections that contain * self references */ static String toString(Collection c) { if (c.size() == 0) { return "[]"; } StringBuffer buf = new StringBuffer(32 * c.size()); buf.append('['); Iterator it = c.iterator(); boolean hasNext = it.hasNext(); while (hasNext) { Object obj = it.next(); buf.append(obj == c ? "(this Collection)" : obj); if (hasNext) { buf.append(", "); } } buf.append("]"); return buf.toString(); } /** * Converts a map to string, supporting maps that contain self references */ static String toString(Map m) { if (m.size() == 0) { return "{}"; } StringBuffer buf = new StringBuffer(32 * m.size()); buf.append('{'); Iterator it = m.entrySet().iterator(); boolean hasNext = it.hasNext(); while (hasNext) { Map.Entry entry = (Map.Entry) it.next(); Object key = entry.getKey(); Object value = entry.getValue(); buf.append(key == m ? "(this Map)" : key).append('=').append(value == m ? "(this Map)" : value); hasNext = it.hasNext(); if (hasNext) { buf.append(',').append(' '); } } buf.append('}'); return buf.toString(); } private transient Entry<K, V>[] table; private transient int count; private int threshold; private final float loadFactor; private final ReferenceQueue<K> queue; private transient volatile int modCount; // Views private transient Set<K> keySet; private transient Set<Map.Entry<K, V>> entrySet; private transient Collection<V> values; public WeakIdentityMap(int initialCapacity, float loadFactor) { if (initialCapacity <= 0) { throw new IllegalArgumentException("Initial capacity must be greater than 0"); } if (loadFactor <= 0 || Float.isNaN(loadFactor)) { throw new IllegalArgumentException("Load factor must be greater than 0"); } this.loadFactor = loadFactor; this.table = new Entry[initialCapacity]; this.threshold = (int) (initialCapacity * loadFactor); this.queue = new ReferenceQueue(); } public WeakIdentityMap(int initialCapacity) { this(initialCapacity, 0.75f); } public WeakIdentityMap() { this(11, 0.75f); } public WeakIdentityMap(Map<? extends K, ? extends V> t) { this(Math.max(2 * t.size(), 11), 0.75f); putAll(t); } public int size() { // Cleanup right before, to report a more accurate size. cleanup(); return this.count; } public boolean isEmpty() { return this.count == 0; } public boolean containsValue(Object value) { Entry[] tab = this.table; if (value == null) { for (int i = tab.length; i-- > 0;) { for (Entry e = tab[i], prev = null; e != null; e = e.next) { if (e.get() == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[i] = e.next; } this.count--; } else if (e.value == null) { return true; } else { prev = e; } } } } else { for (int i = tab.length; i-- > 0;) { for (Entry e = tab[i], prev = null; e != null; e = e.next) { if (e.get() == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[i] = e.next; } this.count--; } else if (value.equals(e.value)) { return true; } else { prev = e; } } } } return false; } public boolean containsKey(Object key) { if (key == null) { key = KeyFactory.NULL; } Entry[] tab = this.table; int hash = System.identityHashCode(key); int index = (hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { Object entryKey = e.get(); if (entryKey == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && key == entryKey) { return true; } else { prev = e; } } return false; } public V get(Object key) { if (key == null) { key = KeyFactory.NULL; } Entry<K, V>[] tab = this.table; int hash = System.identityHashCode(key); int index = (hash & 0x7fffffff) % tab.length; for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) { Object entryKey = e.get(); if (entryKey == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && key == entryKey) { return e.value; } else { prev = e; } } return null; } private void cleanup() { // Cleanup after cleared References. Entry[] tab = this.table; ReferenceQueue queue = this.queue; Reference ref; while ((ref = queue.poll()) != null) { // Since buckets are single-linked, traverse entire list and // cleanup all cleared references in it. int index = (((Entry) ref).hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { if (e.get() == null) { this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else { prev = e; } } } } private void rehash() { int oldCapacity = this.table.length; Entry[] oldMap = this.table; int newCapacity = oldCapacity * 2 + 1; if (newCapacity <= 0) { // Overflow. if ((newCapacity = Integer.MAX_VALUE) == oldCapacity) { return; } } Entry[] newMap = new Entry[newCapacity]; this.modCount++; this.threshold = (int) (newCapacity * this.loadFactor); this.table = newMap; for (int i = oldCapacity; i-- > 0;) { for (Entry old = oldMap[i]; old != null;) { Entry e = old; old = old.next; // Only copy entry if its key hasn't been cleared. if (e.get() == null) { this.count--; } else { int index = (e.hash & 0x7fffffff) % newCapacity; e.next = newMap[index]; newMap[index] = e; } } } } public V put(K key, V value) { if (key == null) { key = (K) KeyFactory.NULL; } cleanup(); // Make sure the key is not already in the WeakIdentityMap. Entry[] tab = this.table; int hash = System.identityHashCode(key); int index = (hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { Object entryKey = e.get(); if (entryKey == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && key == entryKey) { Object old = e.value; e.value = value; return (V) old; } else { prev = e; } } this.modCount++; if (this.count >= this.threshold) { // Rehash the table if the threshold is still exceeded. rehash(); tab = this.table; index = (hash & 0x7fffffff) % tab.length; } // Creates the new entry. Entry e = new Entry(hash, key, this.queue, value, tab[index]); tab[index] = e; this.count++; return null; } public V remove(Object key) { if (key == null) { key = KeyFactory.NULL; } Entry<K, V>[] tab = this.table; int hash = System.identityHashCode(key); int index = (hash & 0x7fffffff) % tab.length; for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) { Object entryKey = e.get(); if (entryKey == null) { // Clean up after a cleared Reference. this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && key == entryKey) { this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; V oldValue = e.value; e.value = null; return oldValue; } else { prev = e; } } return null; } public void putAll(Map<? extends K, ? extends V> t) { Iterator i = t.entrySet().iterator(); while (i.hasNext()) { Map.Entry e = (Map.Entry) i.next(); put((K) e.getKey(), (V) e.getValue()); } } public void clear() { Entry[] tab = this.table; this.modCount++; for (int index = tab.length; --index >= 0;) { tab[index] = null; } this.count = 0; } public Object clone() { try { WeakIdentityMap t = (WeakIdentityMap) super.clone(); t.table = new Entry[this.table.length]; for (int i = this.table.length; i-- > 0;) { t.table[i] = (this.table[i] != null) ? (Entry) this.table[i].copy(this.queue) : null; } t.keySet = null; t.entrySet = null; t.values = null; t.modCount = 0; return t; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); } } public Set<K> keySet() { if (this.keySet == null) { this.keySet = new AbstractSet<K>() { public Iterator iterator() { return createHashIterator(KEYS); } public int size() { return WeakIdentityMap.this.count; } public boolean contains(Object o) { return containsKey(o); } public boolean remove(Object o) { return o == null ? false : WeakIdentityMap.this.remove(o) == o; } public void clear() { WeakIdentityMap.this.clear(); } public String toString() { return WeakIdentityMap.this.toString(this); } }; } return this.keySet; } public Collection<V> values() { if (this.values == null) { this.values = new AbstractCollection<V>() { public Iterator<V> iterator() { return createHashIterator(VALUES); } public int size() { return WeakIdentityMap.this.count; } public boolean contains(Object o) { return containsValue(o); } public void clear() { WeakIdentityMap.this.clear(); } public String toString() { return WeakIdentityMap.this.toString(this); } }; } return this.values; } public Set<Map.Entry<K, V>> entrySet() { if (this.entrySet == null) { this.entrySet = new AbstractSet<Map.Entry<K, V>>() { public Iterator<Map.Entry<K, V>> iterator() { return createHashIterator(ENTRIES); } public boolean contains(Object o) { if (!(o instanceof Map.Entry)) { return false; } Map.Entry entry = (Map.Entry) o; Object key = entry.getKey(); Entry[] tab = WeakIdentityMap.this.table; int hash = System.identityHashCode(key); int index = (hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { Object entryKey = e.get(); if (entryKey == null) { // Clean up after a cleared Reference. WeakIdentityMap.this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } WeakIdentityMap.this.count--; } else if (e.hash == hash && e.equals(entry)) { return true; } else { prev = e; } } return false; } public boolean remove(Object o) { if (!(o instanceof Map.Entry)) { return false; } Map.Entry entry = (Map.Entry) o; Object key = entry.getKey(); Entry[] tab = WeakIdentityMap.this.table; int hash = System.identityHashCode(key); int index = (hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { if (e.get() == null) { // Clean up after a cleared Reference. WeakIdentityMap.this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } WeakIdentityMap.this.count--; } else if (e.hash == hash && e.equals(entry)) { WeakIdentityMap.this.modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } WeakIdentityMap.this.count--; e.value = null; return true; } else { prev = e; } } return false; } public int size() { return WeakIdentityMap.this.count; } public void clear() { WeakIdentityMap.this.clear(); } public String toString() { return WeakIdentityMap.toString(this); } }; } return this.entrySet; } /** * Gets the map as a String. * * @return a string version of the map */ public String toString() { return toString(this); } private Iterator createHashIterator(int type) { if (this.count == 0) { return Collections.EMPTY_SET.iterator(); } else { return new HashIterator(type); } } /** * WeakIdentityMap collision list entry. */ private static class Entry<K, V> extends WeakReference<K> implements Map.Entry<K, V> { int hash; V value; Entry<K, V> next; Entry(int hash, K key, ReferenceQueue<K> queue, V value, Entry<K, V> next) { super(key, queue); this.hash = hash; this.value = value; this.next = next; } public void clear() { // Do nothing if reference is explicity cleared. This prevents // backdoor modification of map entries. } public K getKey() { K key = Entry.this.get(); return key == KeyFactory.NULL ? null : key; } public V getValue() { return this.value; } public V setValue(V value) { V oldValue = this.value; this.value = value; return oldValue; } public boolean equals(Object obj) { if (!(obj instanceof Map.Entry)) { return false; } return equals((Map.Entry) obj); } boolean equals(Map.Entry<K, V> e) { Object thisKey = get(); if (thisKey == null) { return false; } else if (thisKey == KeyFactory.NULL) { thisKey = null; } return (thisKey == e.getKey()) && (this.value == null ? e.getValue() == null : this.value.equals(e.getValue())); } public int hashCode() { return this.hash ^ (this.value == null ? 0 : this.value.hashCode()); } public String toString() { return getKey() + "=" + this.value; } protected Object copy(ReferenceQueue queue) { return new Entry(this.hash, get(), queue, this.value, (this.next == null ? null : (Entry) this.next.copy(queue))); } } private class HashIterator implements Iterator { private final int type; private final Entry[] table; private int index; // To ensure that the iterator doesn't return cleared entries, keep a // hard reference to the key. Its existence will prevent the weak // key from being cleared. Object entryKey; Entry entry; Entry last; /** * The modCount value that the iterator believes that the backing * List should have. If this expectation is violated, the iterator * has detected concurrent modification. */ private int expectedModCount = WeakIdentityMap.this.modCount; HashIterator(int type) { this.table = WeakIdentityMap.this.table; this.type = type; this.index = table.length; } public boolean hasNext() { while (this.entry == null || (this.entryKey = this.entry.get()) == null) { if (this.entry != null) { // Clean up after a cleared Reference. remove(this.entry); this.entry = this.entry.next; } else { if (this.index <= 0) { return false; } else { this.entry = this.table[--this.index]; } } } return true; } public Object next() { if (WeakIdentityMap.this.modCount != this.expectedModCount) { throw new ConcurrentModificationException(); } if (!hasNext()) { throw new NoSuchElementException(); } this.last = this.entry; this.entry = this.entry.next; return this.type == KEYS ? this.last.getKey() : (this.type == VALUES ? this.last.getValue() : this.last); } public void remove() { if (this.last == null) { throw new IllegalStateException(); } if (WeakIdentityMap.this.modCount != this.expectedModCount) { throw new ConcurrentModificationException(); } remove(this.last); this.last = null; } private void remove(Entry toRemove) { Entry[] tab = this.table; int index = (toRemove.hash & 0x7fffffff) % tab.length; for (Entry e = tab[index], prev = null; e != null; e = e.next) { if (e == toRemove) { WeakIdentityMap.this.modCount++; expectedModCount++; if (prev == null) { tab[index] = e.next; } else { prev.next = e.next; } WeakIdentityMap.this.count--; return; } else { prev = e; } } throw new ConcurrentModificationException(); } public String toString() { if (this.last != null) { return "Iterator[" + this.last + ']'; } else { return "Iterator[]"; } } } } /* * Copyright 2004 Brian S O'Neill * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * KeyFactory generates keys which can be hashed or compared for any kind of * object including arrays, arrays of arrays, and null. All hashcode * computations, equality tests, and ordering comparsisons fully recurse into * arrays. * * @author Brian S O'Neill */ class KeyFactory { static final Object NULL = new Comparable() { public int compareTo(Object obj) { return obj == this || obj == null ? 0 : 1; } }; public static Object createKey(boolean[] obj) { return obj == null ? NULL : new BooleanArrayKey(obj); } public static Object createKey(byte[] obj) { return obj == null ? NULL : new ByteArrayKey(obj); } public static Object createKey(char[] obj) { return obj == null ? NULL : new CharArrayKey(obj); } public static Object createKey(double[] obj) { return obj == null ? NULL : new DoubleArrayKey(obj); } public static Object createKey(float[] obj) { return obj == null ? NULL : new FloatArrayKey(obj); } public static Object createKey(int[] obj) { return obj == null ? NULL : new IntArrayKey(obj); } public static Object createKey(long[] obj) { return obj == null ? NULL : new LongArrayKey(obj); } public static Object createKey(short[] obj) { return obj == null ? NULL : new ShortArrayKey(obj); } public static Object createKey(Object[] obj) { return obj == null ? NULL : new ObjectArrayKey(obj); } public static Object createKey(Object obj) { if (obj == null) { return NULL; } if (!obj.getClass().isArray()) { return obj; } if (obj instanceof Object[]) { return createKey((Object[]) obj); } else if (obj instanceof int[]) { return createKey((int[]) obj); } else if (obj instanceof float[]) { return createKey((float[]) obj); } else if (obj instanceof long[]) { return createKey((long[]) obj); } else if (obj instanceof double[]) { return createKey((double[]) obj); } else if (obj instanceof byte[]) { return createKey((byte[]) obj); } else if (obj instanceof char[]) { return createKey((char[]) obj); } else if (obj instanceof boolean[]) { return createKey((boolean[]) obj); } else if (obj instanceof short[]) { return createKey((short[]) obj); } else { return obj; } } static int hashCode(boolean[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { hash = (hash << 1) + (a[i] ? 0 : 1); } return hash == 0 ? -1 : hash; } static int hashCode(byte[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { hash = (hash << 1) + a[i]; } return hash == 0 ? -1 : hash; } static int hashCode(char[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { hash = (hash << 1) + a[i]; } return hash == 0 ? -1 : hash; } static int hashCode(double[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { long v = Double.doubleToLongBits(a[i]); hash = hash * 31 + (int) (v ^ v >>> 32); } return hash == 0 ? -1 : hash; } static int hashCode(float[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { hash = hash * 31 + Float.floatToIntBits(a[i]); } return hash == 0 ? -1 : hash; } static int hashCode(int[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { hash = (hash << 1) + a[i]; } return hash == 0 ? -1 : hash; } static int hashCode(long[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { long v = a[i]; hash = hash * 31 + (int) (v ^ v >>> 32); } return hash == 0 ? -1 : hash; } static int hashCode(short[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { hash = (hash << 1) + a[i]; } return hash == 0 ? -1 : hash; } static int hashCode(Object[] a) { int hash = 0; for (int i = a.length; --i >= 0;) { hash = hash * 31 + hashCode(a[i]); } return hash == 0 ? -1 : hash; } // Compute object or array hashcode and recurses into arrays within. static int hashCode(Object a) { if (a == null) { return -1; } if (!a.getClass().isArray()) { return a.hashCode(); } if (a instanceof Object[]) { return hashCode((Object[]) a); } else if (a instanceof int[]) { return hashCode((int[]) a); } else if (a instanceof float[]) { return hashCode((float[]) a); } else if (a instanceof long[]) { return hashCode((long[]) a); } else if (a instanceof double[]) { return hashCode((double[]) a); } else if (a instanceof byte[]) { return hashCode((byte[]) a); } else if (a instanceof char[]) { return hashCode((char[]) a); } else if (a instanceof boolean[]) { return hashCode((boolean[]) a); } else if (a instanceof short[]) { return hashCode((short[]) a); } else { int hash = a.getClass().hashCode(); return hash == 0 ? -1 : hash; } } // Compares object arrays and recurses into arrays within. static boolean equals(Object[] a, Object[] b) { if (a == b) { return true; } if (a == null || b == null) { return false; } int i; if ((i = a.length) != b.length) { return false; } while (--i >= 0) { if (!equals(a[i], b[i])) { return false; } } return true; } // Compares objects or arrays and recurses into arrays within. static boolean equals(Object a, Object b) { if (a == b) { return true; } if (a == null || b == null) { return false; } Class ac = a.getClass(); if (!(ac.isArray())) { return a.equals(b); } if (ac != b.getClass()) { return false; } if (a instanceof Object[]) { return equals((Object[]) a, (Object[]) b); } else if (a instanceof int[]) { return Arrays.equals((int[]) a, (int[]) b); } else if (a instanceof float[]) { return Arrays.equals((float[]) a, (float[]) b); } else if (a instanceof long[]) { return Arrays.equals((long[]) a, (long[]) b); } else if (a instanceof double[]) { return Arrays.equals((double[]) a, (double[]) b); } else if (a instanceof byte[]) { return Arrays.equals((byte[]) a, (byte[]) b); } else if (a instanceof char[]) { return Arrays.equals((char[]) a, (char[]) b); } else if (a instanceof boolean[]) { return Arrays.equals((boolean[]) a, (boolean[]) b); } else if (a instanceof short[]) { return Arrays.equals((short[]) a, (short[]) b); } else { return a.equals(b); } } static int compare(boolean[] a, boolean[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { int av = a[i] ? 0 : 1; int bv = b[i] ? 0 : 1; return av < bv ? -1 : (av > bv ? 1 : 0); } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } static int compare(byte[] a, byte[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { byte av = a[i]; byte bv = b[i]; return av < bv ? -1 : (av > bv ? 1 : 0); } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } static int compare(char[] a, char[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { char av = a[i]; char bv = b[i]; return av < bv ? -1 : (av > bv ? 1 : 0); } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } static int compare(double[] a, double[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { int v = Double.compare(a[i], b[i]); if (v != 0) { return v; } } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } static int compare(float[] a, float[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { int v = Float.compare(a[i], b[i]); if (v != 0) { return v; } } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } static int compare(int[] a, int[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { int av = a[i]; int bv = b[i]; return av < bv ? -1 : (av > bv ? 1 : 0); } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } static int compare(long[] a, long[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { long av = a[i]; long bv = b[i]; return av < bv ? -1 : (av > bv ? 1 : 0); } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } static int compare(short[] a, short[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { short av = a[i]; short bv = b[i]; return av < bv ? -1 : (av > bv ? 1 : 0); } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } // Compares object arrays and recurses into arrays within. static int compare(Object[] a, Object[] b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } int length = Math.min(a.length, b.length); for (int i = 0; i < length; i++) { int v = compare(a[i], b[i]); if (v != 0) { return v; } } return a.length < b.length ? -1 : (a.length > b.length ? 1 : 0); } // Compares objects or arrays and recurses into arrays within. static int compare(Object a, Object b) { if (a == b) { return 0; } if (a == null) { return 1; } if (b == null) { return -1; } Class ac = a.getClass(); if (!(ac.isArray())) { return ((Comparable) a).compareTo(b); } if (ac != b.getClass()) { throw new ClassCastException(); } if (a instanceof Object[]) { return compare((Object[]) a, (Object[]) b); } else if (a instanceof int[]) { return compare((int[]) a, (int[]) b); } else if (a instanceof float[]) { return compare((float[]) a, (float[]) b); } else if (a instanceof long[]) { return compare((long[]) a, (long[]) b); } else if (a instanceof double[]) { return compare((double[]) a, (double[]) b); } else if (a instanceof byte[]) { return compare((byte[]) a, (byte[]) b); } else if (a instanceof char[]) { return compare((char[]) a, (char[]) b); } else if (a instanceof boolean[]) { return compare((boolean[]) a, (boolean[]) b); } else if (a instanceof short[]) { return compare((short[]) a, (short[]) b); } else { throw new ClassCastException(); } } protected KeyFactory() { } private static interface ArrayKey extends Comparable, java.io.Serializable { int hashCode(); boolean equals(Object obj); int compareTo(Object obj); } private static class BooleanArrayKey implements ArrayKey { protected final boolean[] mArray; private transient int mHash; BooleanArrayKey(boolean[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof BooleanArrayKey ? Arrays.equals(mArray, ((BooleanArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((BooleanArrayKey) obj).mArray); } } private static class ByteArrayKey implements ArrayKey { protected final byte[] mArray; private transient int mHash; ByteArrayKey(byte[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof ByteArrayKey ? Arrays.equals(mArray, ((ByteArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((ByteArrayKey) obj).mArray); } } private static class CharArrayKey implements ArrayKey { protected final char[] mArray; private transient int mHash; CharArrayKey(char[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof CharArrayKey ? Arrays.equals(mArray, ((CharArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((CharArrayKey) obj).mArray); } } private static class DoubleArrayKey implements ArrayKey { protected final double[] mArray; private transient int mHash; DoubleArrayKey(double[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof DoubleArrayKey ? Arrays.equals(mArray, ((DoubleArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((DoubleArrayKey) obj).mArray); } } private static class FloatArrayKey implements ArrayKey { protected final float[] mArray; private transient int mHash; FloatArrayKey(float[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof FloatArrayKey ? Arrays.equals(mArray, ((FloatArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((FloatArrayKey) obj).mArray); } } private static class IntArrayKey implements ArrayKey { protected final int[] mArray; private transient int mHash; IntArrayKey(int[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof IntArrayKey ? Arrays.equals(mArray, ((IntArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((IntArrayKey) obj).mArray); } } private static class LongArrayKey implements ArrayKey { protected final long[] mArray; private transient int mHash; LongArrayKey(long[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof LongArrayKey ? Arrays.equals(mArray, ((LongArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((LongArrayKey) obj).mArray); } } private static class ShortArrayKey implements ArrayKey { protected final short[] mArray; private transient int mHash; ShortArrayKey(short[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof ShortArrayKey ? Arrays.equals(mArray, ((ShortArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((ShortArrayKey) obj).mArray); } } private static class ObjectArrayKey implements ArrayKey { protected final Object[] mArray; private transient int mHash; ObjectArrayKey(Object[] array) { mArray = array; } public int hashCode() { int hash = mHash; return hash == 0 ? mHash = KeyFactory.hashCode(mArray) : hash; } public boolean equals(Object obj) { return this == obj ? true : (obj instanceof ObjectArrayKey ? KeyFactory.equals(mArray, ((ObjectArrayKey) obj).mArray) : false); } public int compareTo(Object obj) { return compare(mArray, ((ObjectArrayKey) obj).mArray); } } }