一、简单描述
Map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,HashTable以及LinkedHashMap等。
TreeMap:能够把它保存的记录根据键(key)排序,默认是按升序排序,也可以指定排序的比较器,该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。
HashMap的值是没有顺序的,它是按照key的HashCode来实现的,根据键可以直接获取它的值,具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。
Map.Entry返回Collections视图。
注:map简单的UML
伦理片 http://www.dotdy.com/
HashMap是按照插入key的hashcode值进行数组排序的,插入排序,不保证稳定性。
TreeMap 接收的comparator的接口默认是key值的排序,源代码如下:
- /**
- * Constructs a new, empty tree map, ordered according to the given
- * comparator. All keys inserted into the map must be <em>mutually
- * comparable</em> by the given comparator: {@code comparator.compare(k1,
- * k2)} must not throw a {@code ClassCastException} for any keys
- * {@code k1} and {@code k2} in the map. If the user attempts to put
- * a key into the map that violates this constraint, the {@code put(Object
- * key, Object value)} call will throw a
- * {@code ClassCastException}.
- *
- * @param comparator the comparator that will be used to order this map.
- * If {@code null}, the {@linkplain Comparable natural
- * ordering} of the keys will be used.
- */
- public TreeMap(Comparator<? super K> comparator) {
- this.comparator = comparator;
- }
注:java8 在Map接口中的Entry接口中实现了根据key、value排序的接口,源代码如下:
- public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
- return (Comparator<Map.Entry<K, V>> & Serializable)
- (c1, c2) -> c1.getKey().compareTo(c2.getKey());
- }
- public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
- return (Comparator<Map.Entry<K, V>> & Serializable)
- (c1, c2) -> c1.getValue().compareTo(c2.getValue());
- }
LinkedHashMap重写了Entry实现类,实现成双向链表的类型结构,会存取borfer和after的元素,插入的时候把当前元素插入到链表头部,
继承自HashMap,一个有序的Map接口实现,这里的有序指的是元素可以按插入顺序或访问顺序排列;
与HashMap的异同:同样是基于散列表实现,区别是,LinkedHashMap内部多了一个双向循环链表的维护,该链表是有序的,可以按元素插入顺序或元素最近访问顺序(LRU)排列,
简单地说:LinkedHashMap=散列表+循环双向链表
- package java.util;
- import java.io.*;
- public class LinkedHashMap<K,V>
- extends HashMap<K,V>
- implements Map<K,V>
- {
- private static final long serialVersionUID = 3801124242820219131L;
- /**
- * 双向循环链表, 头结点(空节点)
- */
- private transient Entry<K,V> header;
- /**
- * accessOrder为true时,按访问顺序排序,false时,按插入顺序排序
- */
- private final boolean accessOrder;
- /**
- * 生成一个空的LinkedHashMap,并指定其容量大小和负载因子,
- * 默认将accessOrder设为false,按插入顺序排序
- */
- public LinkedHashMap(int initialCapacity, float loadFactor) {
- super(initialCapacity, loadFactor);
- accessOrder = false;
- }
- /**
- * 生成一个空的LinkedHashMap,并指定其容量大小,负载因子使用默认的0.75,
- * 默认将accessOrder设为false,按插入顺序排序
- */
- public LinkedHashMap(int initialCapacity) {
- super(initialCapacity);
- accessOrder = false;
- }
- /**
- * 生成一个空的HashMap,容量大小使用默认值16,负载因子使用默认值0.75
- * 默认将accessOrder设为false,按插入顺序排序.
- */
- public LinkedHashMap() {
- super();
- accessOrder = false;
- }
- /**
- * 根据指定的map生成一个新的HashMap,负载因子使用默认值,初始容量大小为Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,DEFAULT_INITIAL_CAPACITY)
- * 默认将accessOrder设为false,按插入顺序排序.
- */
- public LinkedHashMap(Map<? extends K, ? extends V> m) {
- super(m);
- accessOrder = false;
- }
- /**
- * 生成一个空的LinkedHashMap,并指定其容量大小和负载因子,
- * 默认将accessOrder设为true,按访问顺序排序
- */
- public LinkedHashMap(int initialCapacity,
- float loadFactor,
- boolean accessOrder) {
- super(initialCapacity, loadFactor);
- this.accessOrder = accessOrder;
- }
- /**
- * 覆盖HashMap的init方法,在构造方法、Clone、readObject方法里会调用该方法
- * 作用是生成一个双向链表头节点,初始化其前后节点引用
- */
- @Override
- void init() {
- header = new Entry<>(-1, null, null, null);
- header.before = header.after = header;
- }
- /**
- * 覆盖HashMap的transfer方法,性能优化,这里遍历方式不采用HashMap的双重循环方式
- * 而是直接通过双向链表遍历Map中的所有key-value映射
- */
- @Override
- void transfer(HashMap.Entry[] newTable, boolean rehash) {
- int newCapacity = newTable.length;
- //遍历旧Map中的所有key-value
- for (Entry<K,V> e = header.after; e != header; e = e.after) {
- if (rehash)
- e.hash = (e.key == null) ? 0 : hash(e.key);
- //根据新的数组长度,重新计算索引,
- int index = indexFor(e.hash, newCapacity);
- //插入到链表表头
- e.next = newTable[index];
- //将e放到索引为i的数组处
- newTable[index] = e;
- }
- }
- /**
- * 覆盖HashMap的transfer方法,性能优化,这里遍历方式不采用HashMap的双重循环方式
- * 而是直接通过双向链表遍历Map中的所有key-value映射,
- */
- public boolean containsValue(Object value) {
- // Overridden to take advantage of faster iterator
- if (value==null) {
- for (Entry e = header.after; e != header; e = e.after)
- if (e.value==null)
- return true;
- } else {
- for (Entry e = header.after; e != header; e = e.after)
- if (value.equals(e.value))
- return true;
- }
- return false;
- }
- /**
- * 通过key获取value,与HashMap的区别是:当LinkedHashMap按访问顺序排序的时候,会将访问的当前节点移到链表尾部(头结点的前一个节点)
- */
- public V get(Object key) {
- Entry<K,V> e = (Entry<K,V>)getEntry(key);
- if (e == null)
- return null;
- e.recordAccess(this);
- return e.value;
- }
- /**
- * 调用HashMap的clear方法,并将LinkedHashMap的头结点前后引用指向自己
- */
- public void clear() {
- super.clear();
- header.before = header.after = header;
- }
- /**
- * LinkedHashMap节点对象
- */
- private static class Entry<K,V> extends HashMap.Entry<K,V> {
- // 节点前后引用
- Entry<K,V> before, after;
- //构造函数与HashMap一致
- Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
- super(hash, key, value, next);
- }
- /**
- * 移除节点,并修改前后引用
- */
- private void remove() {
- before.after = after;
- after.before = before;
- }
- /**
- * 将当前节点插入到existingEntry的前面
- */
- private void addBefore(Entry<K,V> existingEntry) {
- after = existingEntry;
- before = existingEntry.before;
- before.after = this;
- after.before = this;
- }
- /**
- * 在HashMap的put和get方法中,会调用该方法,在HashMap中该方法为空
- * 在LinkedHashMap中,当按访问顺序排序时,该方法会将当前节点插入到链表尾部(头结点的前一个节点),否则不做任何事
- */
- void recordAccess(HashMap<K,V> m) {
- LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
- //当LinkedHashMap按访问排序时
- if (lm.accessOrder) {
- lm.modCount++;
- //移除当前节点
- remove();
- //将当前节点插入到头结点前面
- addBefore(lm.header);
- }
- }
- void recordRemoval(HashMap<K,V> m) {
- remove();
- }
- }
- //迭代器
- private abstract class LinkedHashIterator<T> implements Iterator<T> {
- //初始化下个节点引用
- Entry<K,V> nextEntry = header.after;
- Entry<K,V> lastReturned = null;
- /**
- * 用于迭代期间快速失败行为
- */
- int expectedModCount = modCount;
- //链表遍历结束标志,当下个节点为头节点的时候
- public boolean hasNext() {
- return nextEntry != header;
- }
- //移除当前访问的节点
- public void remove() {
- //lastReturned会在nextEntry方法中赋值
- if (lastReturned == null)
- throw new IllegalStateException();
- //快速失败机制
- if (modCount != expectedModCount)
- throw new ConcurrentModificationException();
- LinkedHashMap.this.remove(lastReturned.key);
- lastReturned = null;
- //迭代器自身删除节点,并不是其他线程修改Map结构,所以这里要修改expectedModCount
- expectedModCount = modCount;
- }
- //返回链表下个节点的引用
- Entry<K,V> nextEntry() {
- //快速失败机制
- if (modCount != expectedModCount)
- throw new ConcurrentModificationException();
- //链表为空情况
- if (nextEntry == header)
- throw new NoSuchElementException();
- //给lastReturned赋值,最近一个从迭代器返回的节点对象
- Entry<K,V> e = lastReturned = nextEntry;
- nextEntry = e.after;
- return e;
- }
- }
- //key迭代器
- private class KeyIterator extends LinkedHashIterator<K> {
- public K next() { return nextEntry().getKey(); }
- }
- //value迭代器
- private class ValueIterator extends LinkedHashIterator<V> {
- public V next() { return nextEntry().value; }
- }
- //key-value迭代器
- private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
- public Map.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(); }
- /**
- * 创建节点,插入到LinkedHashMap中,该方法覆盖HashMap的addEntry方法
- */
- void addEntry(int hash, K key, V value, int bucketIndex) {
- super.addEntry(hash, key, value, bucketIndex);
- // 注意头结点的下个节点即header.after,存放于链表头部,是最不经常访问或第一个插入的节点,
- //有必要的情况下(如容量不够,具体看removeEldestEntry方法的实现,这里默认为false,不删除),可以先删除
- Entry<K,V> eldest = header.after;
- if (removeEldestEntry(eldest)) {
- removeEntryForKey(eldest.key);
- }
- }
- /**
- * 创建节点,并将该节点插入到链表尾部
- */
- void createEntry(int hash, K key, V value, int bucketIndex) {
- HashMap.Entry<K,V> old = table[bucketIndex];
- Entry<K,V> e = new Entry<>(hash, key, value, old);
- table[bucketIndex] = e;
- //将该节点插入到链表尾部
- e.addBefore(header);
- size++;
- }
- /**
- * 该方法在创建新节点的时候调用,
- * 判断是否有必要删除链表头部的第一个节点(最不经常访问或最先插入的节点,由accessOrder决定)
- */
- protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
- return false;
- }
- }
重写了Iterator的实现LinkedHashIterator,遍历的时候按照双向链表的顺序进行遍历,不是按照桶里数组的顺序进行遍历(HashMap).
AbstractMap中的toString方法即调用的entrySet()方法,进行的遍历打印的值。
图解:
第一张图是LinkedHashMap的全部数据结构,包含散列表和循环双向链表,由于循环双向链表线条太多了,不好画,简单的画了一个节点(黄色圈出来的)示意一下,注意左边的红色箭头引用为Entry节点对象的next引用(散列表中的单链表),绿色线条为Entry节点对象的before, after引用(循环双向链表的前后引用);