Map 接口
package util; import java.util.Collection; import java.util.Set; public interface Map<K, V> { int size(); boolean isEmpty(); boolean containsKey(Object key); boolean containsValue(Object val); V get(K key); V put(K key, V val); V remove(Object key); void putAll(Map<? extends K, ? extends V> map); void clear(); Set<K> keySet(); Collection<V> values(); Set<Map.Entry<K, V>> entrySet(); interface Entry<K, V> { K getKey(); V getValue(); V setValue(V val); boolean equals(Object o); int hashCode(); } boolean equals(Object o); int hashCode(); }
AbstractMap 抽象类
package util; import java.util.AbstractCollection; import java.util.AbstractSet; import java.util.Collection; import java.util.Iterator; import java.util.Set; /** * AbstarctMap 的方法实现都是靠遍历 entrySet 来确定带操作元素的位置 * 实际上 AbstractMap 实现的方法大部分都需要在子类中重写 * * @author alexis * * @param <K> * @param <V> */ public abstract class AbstractMap<K, V> implements Map<K, V> { protected AbstractMap() { } public int size() { return entrySet().size(); } public boolean isEmpty() { return size() == 0; } public boolean containsKey(Object key) { Iterator<Map.Entry<K, V>> i = entrySet().iterator(); if (key == null) { while (i.hasNext()) if (i.next().getKey() == null) return true; } else { while (i.hasNext()) { if (i.next().getKey().equals(key)) return true; } } return false; } public boolean containsValue(Object val) { Iterator<Map.Entry<K, V>> i = entrySet().iterator(); if (val == null) { while (i.hasNext()) if (i.next().getValue() == null) return true; } else { while (i.hasNext()) { if (i.next().getValue().equals(val)) return true; } } return false; } public V get(K key) { Iterator<Map.Entry<K, V>> i = entrySet().iterator(); if (key == null) { while (i.hasNext()) { Map.Entry<K, V> entry = i.next(); if (entry.getKey() == null) return entry.getValue(); } } else { while (i.hasNext()) { Map.Entry<K, V> entry = i.next(); if (entry.getKey().equals(key)) return entry.getValue(); } } return null; } public V put(K key, V value) { throw new UnsupportedOperationException(); } public V remove(Object key) { Iterator<Map.Entry<K, V>> i = entrySet().iterator(); while (i.hasNext()) { Map.Entry<K, V> entry = i.next(); if ((key == null && entry.getKey() == null) || (key != null && entry.getKey().equals(key))) { i.remove(); return entry.getValue(); } } return null; } public void putAll(Map<? extends K, ? extends V> map) { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) put(entry.getKey(), entry.getValue()); } public void clear() { entrySet().clear(); } transient volatile Set<K> keySet = null; transient volatile Collection<V> values = null; public Set<K> keySet() { if (keySet == null) { keySet = new AbstractSet<K>() { @Override public Iterator<K> iterator() { return new Iterator<K>() { private Iterator<Map.Entry<K, V>> i = entrySet() .iterator(); @Override public boolean hasNext() { return i.hasNext(); } @Override public K next() { return i.next().getKey(); } @Override public void remove() { i.remove(); } }; } @Override public int size() { return AbstractMap.this.size(); } public boolean contains(Object key) { return AbstractMap.this.containsKey((K) key); } }; } return keySet; } public Collection<V> values() { if (values == null) { new AbstractCollection<V>() { @Override public Iterator<V> iterator() { return new Iterator<V>() { private Iterator<Map.Entry<K, V>> i = entrySet() .iterator(); @Override public boolean hasNext() { return i.hasNext(); } @Override public V next() { return i.next().getValue(); } @Override public void remove() { i.remove(); } }; } @Override public int size() { return AbstractMap.this.size(); } public boolean contains(Object obj) { return AbstractMap.this.containsValue((V) obj); } }; } return values; } public abstract Set<Map.Entry<K, V>> entrySet(); public boolean equals(Map<K, V> map) { if (map == this) return true; if (map.size() != size()) return false; Iterator<Map.Entry<K, V>> i = entrySet().iterator(); while (i.hasNext()) { Entry<K, V> entry = i.next(); K key = entry.getKey(); V value = entry.getValue(); if (!map.containsKey(key) || !map.containsValue(value)) return false; } return true; } public int hashCode() { int h = 0; Iterator<Map.Entry<K, V>> i = entrySet().iterator(); while (i.hasNext()) { h += i.next().hashCode(); } return h; } public String toString() { Iterator<Map.Entry<K, V>> i = entrySet().iterator(); if (!i.hasNext()) return "{}"; StringBuilder sb = new StringBuilder(); sb.append("{"); while (true) { Map.Entry<K, V> entry = i.next(); K key = entry.getKey(); V val = entry.getValue(); sb.append(key == this ? "(this map)" : key); sb.append("="); sb.append(val == this ? "(this map)" : val); if (!i.hasNext()) { return sb.append("}").toString(); } sb.append(", "); } } protected Object clone() throws CloneNotSupportedException { AbstractMap<K, V> result = (AbstractMap<K, V>) super.clone(); result.keySet = null; result.values = null; return result; } private static boolean eq(Object o1, Object o2) { return o1 == null ? o2 == null : o1.equals(o2); } public static class SimpleEntry<K, V> implements Map.Entry<K, V>, java.io.Serializable { private static final long serialVersionUID = -8499721149061103585L; private final K key; private V value; public SimpleEntry(K key, V value) { this.key = key; this.value = value; } public SimpleEntry(Map.Entry<? extends K, ? extends V> entry) { this.key = entry.getKey(); this.value = entry.getValue(); } @Override public K getKey() { return key; } @Override public V getValue() { return value; } @Override public V setValue(V val) { V oldValue = this.value; this.value = val; return oldValue; } @Override public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry entry = (Map.Entry) o; return eq(key, entry.getKey()) && eq(value, entry.getValue()); } @Override public int hashCode() { return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode()); } @Override public String toString() { return key + "=" + value; } } public static class SimpleImmutableEntry<K, V> implements Entry<K, V>, java.io.Serializable { private static final long serialVersionUID = 7138329143949025153L; private final K key; private final V value; public SimpleImmutableEntry(K key, V value) { this.key = key; this.value = value; } public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) { this.key = entry.getKey(); this.value = entry.getValue(); } public K getKey() { return key; } public V getValue() { return value; } public V setValue(V value) { throw new UnsupportedOperationException(); } public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry) o; return eq(key, e.getKey()) && eq(value, e.getValue()); } public int hashCode() { return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode()); } public String toString() { return key + "=" + value; } } }
HashMap类
package util; import java.io.IOException; import java.util.AbstractCollection; import java.util.AbstractSet; import java.util.Collection; import java.util.ConcurrentModificationException; import java.util.Iterator; import java.util.NoSuchElementException; import java.util.Set; public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V> { /** * 默认的初始化table容量 */ static final int DEFAULT_INITIAL_CAPACITY = 16; /** * 最大table容量 */ static final int MAXIMUM_CAPACITY = 1 << 30; /** * 默认负载系数 */ static final float DEFAULT_LOAD_FACTOR = 0.75f; /** * 实际存放HashMap数据的Entry数组 */ transient Entry[] table; /** * 当前HashMap元素个数(注意：不等与table.length) */ transient int size; /** * 阈值，当size超过threshold时，table将会扩容 * threshold = capacity * loadFactor */ int threshold; /** * 负载系数，作用见阈值 */ final float loadFactor; /** * Map元素的增删次数，作用是用来确定获取Iterator后 * 保证Map的元素不变，详见 HashIterator */ transient volatile int modCount; public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); int capacity = 1; // table容量只能为2的方幂 while (capacity < initialCapacity) capacity <<= 1; this.loadFactor = loadFactor; threshold = (int) (capacity * loadFactor); table = new Entry[capacity]; init(); } public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); } public HashMap(Map<? extends K, ? extends V> map) { this(Math.max((int) (map.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); putAllForCreate(map); } void init() {} /** * 大名鼎鼎的hash算法，原来是这样的 * * @param h * @return */ static int hash(int h) { h ^= (h >>> 20 ) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } /** * 通过hash值确定元素在table中的下标 * * @param h * @param length * @return */ static int indexFor(int h, int length) { return h & (length - 1); } public int size() { return size; } public boolean isEmpty() { return size == 0; } /** * 通过key获取value，获取步骤： * 1. 通过key的hash值确定table下标 * 2. 遍历table下标对应的链表(这个链表就是解决冲突用的) * 3. 返回key值匹配的value */ public V get(K key) { if (key == null) return getForNullKey(); int hash = hash(key.hashCode()); for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { K k; if (e.hash == hash && ((k = e.key) == key || e.equals(k))) return e.value; } return null; } /** * 容易看出key为null的Entry存在table[0] * * @return */ private V getForNullKey() { for (Entry<K, V> e = table[0]; e != null; e = e.next) { if (e.key == null) return e.value; } return null; } public boolean containsKey(Object o) { return getEntry(o) != null; } /** * 与get()方法类似，只不过返回的是Entry * * @param key * @return */ final Entry<K, V> getEntry(Object key) { int hash = (key == null) ? 0 : hash(key.hashCode()); for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { K k; if ((e.hash == hash) && ((k = e.key) == key || (k != null && k.equals(key)))) return e; } return null; } /** * 插入方法，插入步骤为: * 1. 通过key的hash值确定table下标 * 2. 查找table下标的链表，如果key存在则更新对应的value * 3. 如果key不存在则调用addEntry()方法, 这种情况包括key冲突 */ public V put(K key, V val) { if (key == null) return putForNullKey(val); int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); for (Entry<K, V> e = table[i]; e != null; e = e.next) { if (e.hash == hash && (e.key == key || e.key.equals(key))) { V oldValue = e.value; e.value = val; e.recordAccess(this); return oldValue; } } modCount++; addEntry(hash, key, val, i); return null; } /** * null值都插入table[0] * * @param value * @return */ private V putForNullKey(V value) { for (Entry<K, V> e = table[0]; e != null; e = e.next) { if (e.key == null){ V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(0, null, value, 0); return null; } /** * 类似与put()方法，区别在于没有返回值 * 以及不需要考虑modCount的变化 * * @param key * @param val */ private void putForCreate(K key, V val) { int hash = (key == null) ? 0 : hash(key.hashCode()); int i = indexFor(hash, table.length); for (Entry<K, V> e = table[i]; e != null; e = e.next) { if (hash == e.hash && (e.key == key || (e.key != null && e.key.equals(key)))) { e.value = val; return; } } createEntry(hash, key, val, i); } private void putAllForCreate(Map<? extends K, ? extends V> map) { for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = map.entrySet().iterator(); i.hasNext();) { Map.Entry<? extends K, ? extends V> entry = i.next(); putForCreate(entry.getKey(), entry.getValue()); } } /** * table扩容方法 * * @param newCapacity */ void resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } Entry[] newTable = new Entry[newCapacity]; // 将所有旧table中的Entry复制到新的table transfer(newTable); table = newTable; threshold = (int) (newCapacity * loadFactor); } /** * 转移方法，将会重新计算所有Entry的下标 * * @param newTable */ void transfer(Entry[] newTable) { Entry[] src = table; int newCapacity = newTable.length; for (int i = 0; i < src.length; i++) { Entry<K, V> e = src[i]; if (e != null) { src[i] = null; do { Entry<K, V> next = e.next; int j = indexFor(e.hash, newCapacity); e.next = newTable[j]; newTable[j] = e; e = next; } while (e != null); } } } /** * 将参数map中所有Entry加入到当前map */ public void putAll(Map<? extends K, ? extends V> map) { int numKeysToBeAdded = map.size(); if (numKeysToBeAdded == 0) return; /** * 当 map.size() > threshold 时重新计算table容量 * 这里不选取 (table.length + map.size()) 作为新的容量是因为 * table与map中的Entry的key有可能存在重复，而造成table容量浪费 * 而如果使用 map.size() 作为阈值来计算新的容量，则最多只需要 * 在当 size > threshold 时调用put()的时候进行一次 2倍 扩容即可 */ if (numKeysToBeAdded > threshold) { int targetCapacity = (int) (numKeysToBeAdded / loadFactor + 1); if (targetCapacity > MAXIMUM_CAPACITY) targetCapacity = MAXIMUM_CAPACITY; int newCapacity = table.length; while (newCapacity < targetCapacity) newCapacity <<= 1; if (newCapacity > table.length) resize(newCapacity); } for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = entrySet().iterator(); i.hasNext();) { Map.Entry<? extends K, ? extends V> e = i.next(); put(e.getKey(), e.getValue()); } } /** * 通过 Key 来删除节点 */ public V remove(Object key) { Entry<K, V> e = removeEntryForKey(key); return e == null ? null : e.value; } final Entry<K, V> removeEntryForKey(Object key) { int hash = (key == null) ? 0 : hash(key.hashCode()); int i = indexFor(hash, table.length); Entry<K, V> prev = table[i]; for (Entry<K, V> e = table[i]; e != null; e = e.next) { if (e.hash == hash || (key == e.key || (e.key != null && e.key.equals(key)))) { modCount++; size--; // 注意此处删除链表节点的操作 if (e == prev) table[i] = e.next; else prev.next = prev.next.next; e.recordRemoval(this); return e; } prev = e; e = e.next; } return null; } /** * 通过 Entry 来删除节点 * * @param o * @return */ final Entry<K, V> removeMapping(Object o) { if (!(o instanceof Map.Entry)) return null; Map.Entry<K, V> entry = (Map.Entry<K, V>) o; K k = entry.getKey(); int hash = (k == null) ? 0 : hash(k.hashCode()); int i = indexFor(hash, table.length); Entry<K, V> prev = table[i]; for (Entry<K, V> e = table[i]; e != null; e = e.next) { if (e.hash == hash && e.equals(entry)) { modCount++; size--; if (e == prev) table[i] = e.next; else prev.next = e.next.next; e.recordRemoval(this); return e; } prev = e; e = e.next; } return null; } public void clear() { modCount++; for (int i = 0; i < table.length; i++) { table[i] = null; } size = 0; } public boolean containsValue(Object value) { if (value == null) containsNullValue(); for (int i = 0; i < table.length; i++) for (Entry<K, V> e = table[i]; e != null; e = e.next) if (value.equals(e.value)) return true; return false; } private boolean containsNullValue() { for (int i = 0; i < table.length; i++) for (Entry<K, V> e = table[i]; e != null; e = e.next) if (e.value == null) return true; return false; } public Object clone() { HashMap<K, V> result = null; try { result = (HashMap<K, V>) super.clone(); } catch (CloneNotSupportedException e) { // TODO: handle exception } result.table = new Entry[table.length]; result.entrySet = null; result.modCount = 0; result.size = 0; result.init(); result.putAllForCreate(this); return result; } /** * HashMap中真正存储元素的节点， * 也是冲突链表的链表节点 * * @author alexis * * @param <K> * @param <V> */ static class Entry<K, V> implements Map.Entry<K, V> { final K key; V value; final int hash; Entry<K, V> next; Entry(int hash, K key, V value, Entry<K, V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } @Override public K getKey() { return key; } @Override public V getValue() { return value; } @Override public V setValue(V val) { V oldValue = value; value = val; return oldValue; } /** * 只有比较的Key和Value都相等才相等 */ @Override public final boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<K, V> e = (Map.Entry<K, V>) o; K k1 = getKey(); K k2 = e.getKey(); if (k1 == k2 || (k1 != null && k1.equals(k2))) { V v1 = getValue(); V v2 = e.getValue(); if (v1 == v2 || (v1 != null && v1.equals(v2))) return true; } return false; } @Override public final int hashCode() { return ((key == null) ? 0 : key.hashCode()) ^ ((value == null) ? 0 : value.hashCode()); } @Override public final String toString() { return key + "=" + value; } void recordAccess(HashMap<K, V> map) {} void recordRemoval(HashMap<K, V> map) {} } /** * 添加新Entry，table扩容就在此处 * * @param hash * @param key * @param value * @param bucketIndex */ void addEntry(int hash, K key, V value, int bucketIndex) { Entry<K, V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K, V>(hash, key, value, e); if (size++ >= threshold) resize(2 * table.length); } /** * 添加创建Map时的节点，不用考虑扩容问题 * * @param hash * @param key * @param value * @param bucketIndex */ void createEntry(int hash, K key, V value, int bucketIndex) { Entry<K, V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K, V>(hash, key, value, e); size++; } /** * HashMap的遍历其，其特点有： * 1. 含有 expectedModCount，可防止获取Iterator后HashMap size发生变化 * 2. 由于hash算法的原因，Entry在table中是无序不规则存储，调用next时需要 * 自动跳过null元素 * * @author alexis * * @param <E> */ private abstract class HashIterator<E> implements Iterator<E> { Entry<K, V> next; int expectedModCount; int index; Entry<K, V> current; public HashIterator() { expectedModCount = modCount; if (size > 0) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } } public final boolean hasNext() { return next != null; } final Entry<K, V> nextEntry() { // 当获取Iterator后Map size发生变化，则会抛出异常 if (modCount != expectedModCount) throw new ConcurrentModificationException(); Entry<K, V> e = next; // 当已经不存在一下个元素时，抛出异常 if (e == null) throw new NoSuchElementException(); if ((next = e.next) == null) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } current = e; return e; } /** * 次方法用来删除next方法最后返回的那个元素 */ public void remove() { if (current == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); K k = current.key; current = null; HashMap.this.remove(k); expectedModCount = modCount; } } /** * 下面的各种 Iterator 就是重写了 next() 方法而已 * @author alexis * */ private final class ValueIterator extends HashIterator<V> { public V next() { return nextEntry().value; } } private final class KeyIterator extends HashIterator<K> { @Override public K next() { return nextEntry().key; } } private final class EntryIterator extends HashIterator<Map.Entry<K, V>> { @Override public Entry<K, V> next() { return nextEntry(); } } Iterator<K> newKeyIterator() { return new KeyIterator(); } Iterator<V> newValueIterator() { return new ValueIterator(); } Iterator<Map.Entry<K, V>> newEntryIterator() { return new EntryIterator(); } private transient Set<Map.Entry<K, V>> entrySet; public Set<K> keySet() { Set<K> ks = keySet; return (ks != null) ? ks : (keySet = new KeySet()); } private final class KeySet extends AbstractSet<K> { @Override public Iterator<K> iterator() { return newKeyIterator(); } @Override public int size() { return size; } public boolean contains(Object o) { return containsKey(o); } public boolean remove(Object o) { return HashMap.this.removeEntryForKey(o) != null; } public void clear() { HashMap.this.clear(); } } public Collection<V> values() { Collection<V> vs = values; return (vs != null) ? vs : (values = new Values()); } private final class Values extends AbstractCollection<V> { @Override public Iterator<V> iterator() { return new ValueIterator(); } @Override public int size() { return size; } public boolean contains(Object o) { return containsValue(o); } public void clear() { HashMap.this.clear(); } } public Set<Map.Entry<K, V>> entrySet() { return entrySet0(); } private Set<Map.Entry<K, V>> entrySet0() { Set<Map.Entry<K, V>> es = entrySet; return (es != null) ? es : (entrySet = new EntrySet()); } /** * 请注意 AbstractSet 是没有get()方法的， * 原因是 HashSet 是哈希存储，内部是乱序的， * 无法通过坐标获取值，其唯一的访问方法是通过Iterator * * @author alexis * */ private final class EntrySet extends AbstractSet<Map.Entry<K, V>> { @Override public Iterator<util.Map.Entry<K, V>> iterator() { return new EntryIterator(); } @Override public int size() { return size; } public boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<K, V> e = (Map.Entry<K, V>) o; Entry<K, V> candidate = getEntry(e.getKey()); return candidate != null && candidate.equals(e); } public boolean remove(Object o) { return removeMapping(o) != null; } public void clear() { HashMap.this.clear(); } } /** * 序列化与反序列化方法 * @param s * @throws IOException */ private void writeObject(java.io.ObjectOutputStream s) throws IOException { Iterator<Map.Entry<K, V>> i = (size > 0) ? entrySet0().iterator() : null; s.defaultWriteObject(); s.writeInt(table.length); s.writeInt(size); if (i != null) { while (i.hasNext()) { Map.Entry<K, V> e = i.next(); s.writeObject(e.getKey()); s.writeObject(e.getValue()); } } } private final static long serialVersionUID = 362498820763181265L; private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { s.defaultReadObject(); int numBuckets = s.readInt(); table = new Entry[numBuckets]; init(); int size = s.readInt(); for (int i = 0; i < size; i++) { K key = (K) s.readObject(); V value = (V) s.readObject(); putForCreate(key, value); } } int capacity() { return table.length; } int loadFactor() { return loadFactor(); } }
