集合框架源码分析五之LinkedHashMap,LinkedHashSet
LinkedHashMap是为了解决遍历Hash表的无序问题,它内部维护了一个链表用于记录你插入元素(或你访问元素的顺序)的位置,遍历时直接遍历链表,元素的顺序即为你插入的顺序,但是Entry对象要多加两个成员变量before和after用于记录链表的前驱和后继。所以LinkedHashMap的的存储效率要低于HashMap,但是遍历效率要高于HashMap。
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
/**
* LinkedHashMap内部不仅存储了一个散列表,
* 也维护了一个链表,
* 根据链表中元素的顺序可以分为:按插入顺序的链表,和按访问顺序(调用get方法)的链表。
* 默认是按插入顺序排序,如果指定按访问顺序排序,那么调用get方法后,会将这次访问的元素
* 移至链表尾部,不断访问可以形成按访问顺序排序的链表。
* 可以重写removeEldestEntry方法返回true值指定插入元素时移除最老的元素
*/
public class LinkedHashMap<K,V> extends HashMap<K,V>
implements Map<K,V>
{
private static final long serialVersionUID = 3801124242820219131L;
/**
* 此Map中维护的一个双向循环链表的头节点
*/
private transient Entry<K,V> header;
/**
*
* 遍历Map的顺序的变量,
* true为按访问顺序遍历
* false为按插入顺序遍历
*/
private final boolean accessOrder;
/**
*
* 构造一个空的,按插入顺序遍历的LinkedHashMap实例,
* 初始容量与加载因子由自己指定
*/
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
/**
* 构造一个空的,按插入顺序遍历的LinkedHashMap实例,
* 初始容量由自己指定
*/
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
/**
*
* 构造一个空的,按插入顺序遍历的LinkedHashMap实例
* 初始容量与加载因子按HashMap的默认值16与0.75
*/
public LinkedHashMap() {
super();
accessOrder = false;
}
/**
* 构造一个非空,按插入顺序遍历的LinkedHashMap实例
*/
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super(m);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
/**
*
* 在HashMap每个构造方法中都会调用一次此init()方法
* 这里是初始化一个双向循环链表的头节点
*/
void init() {
header = new Entry<K,V>(-1, null, null, null);
header.before = header.after = header;
}
/**
*
* 在父类HashMap进行容量扩充时会调用此方法
* 把原来Entry数组中的对象经过重新计算索引转移到此newTable中
* 这里与HashMap中的transfer方法的实现不再相同,而且比它更快。
*
* HashMap是遍历Entry数组,需要检查是否为null,如果不为空的话则就需
* 要遍历数组中的链表,而这里所有的元素都链接成了一个链表,直接遍历此
* 链表就可以遍历出LinkedHashMap中的所有元素。
*/
void transfer(HashMap.Entry[] newTable) {
int newCapacity = newTable.length;
for (Entry<K,V> e = header.after; e != header; e = e.after) {
int index = indexFor(e.hash, newCapacity); //根据新容量重新计算index
e.next = newTable[index]; //最后添加的节点放最前面
newTable[index] = e;
}
}
/**
*
* 查找Map中是否含有本值,这里重写了HashMap的containsValue方法
* 因为在LinkedHashMap中只需要遍历链表查找,这比HashMap遍历table查找更加
* 高效和快速
*/
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,如果没有找到此key则返回null。
* 不过返回null也可能是其value为null
* 通过contain方法可判断Map中是否含有此键
*
* 重写此方法的原因是:
* 如果map中链表是按照访问顺序进行排序,
* 就需要把本次访问的元素移到链表尾部,表示
* 这是你最新访问的元素,以后可能会继续访问它
*
*/
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;
}
/**
* 移除元素,清空链表
*/
public void clear() {
super.clear();
header.before = header.after = header;
}
/**
* LinkedHashMap 的Entry对象.
*/
private static class Entry<K,V> extends HashMap.Entry<K,V> {
// 包含其前驱和后继的信息.
Entry<K,V> before, after;
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;
}
/**
*
* 把元素插入到指定的存在的元素之前
* 链表的插入也是修改指针
*/
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
/**
*
* 当调用父类的put或putAll方法,发现要插入的键已经存在时会调用此方法,
* 当调用LinkedHashMap的get方法时会调用此方法。
* 如果LinkedHashMap是按访问顺序遍历的,就移动此Entry
* 到链表的最后位置,否则do nothing
*/
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
if (lm.accessOrder) {
lm.modCount++;
remove(); //移除它
addBefore(lm.header); //再把她添加到链表尾部
}
}
/**
* 在移除元素时会调用此方法,即调用
* 父类的remove(key)方法时调用它
* 这里是改变链表指针,移除链表中的此元素
*/
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() {
if (lastReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
LinkedHashMap.this.remove(lastReturned.key);
lastReturned = null;
expectedModCount = modCount;
}
Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (nextEntry == header)
throw new NoSuchElementException();
Entry<K,V> e = lastReturned = nextEntry;
nextEntry = e.after;
return e;
}
}
//依次重写next方法,返回不同的迭代器。
private class KeyIterator extends LinkedHashIterator<K> {
public K next() { return nextEntry().getKey(); }
}
private class ValueIterator extends LinkedHashIterator<V> {
public V next() { return nextEntry().value; }
}
private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() { return nextEntry(); }
}
// These Overrides alter the behavior of superclass view iterator() methods
Iterator<K> newKeyIterator() { return new KeyIterator(); }
Iterator<V> newValueIterator() { return new ValueIterator(); }
Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }
/**
*
* 重写父类addEntry方法
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
createEntry(hash, key, value, bucketIndex);
/*如果子类重写了removeEldestEntry方法并返回true,
将在map中移除链表中的第一个元素,否则检测是否需要扩充容量。
eldest元素即为链表中的第一个元素*/
Entry<K,V> eldest = header.after;
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
} else {
if (size >= threshold)
resize(2 * table.length); //扩充至原来的2倍
}
}
/**
*
* 重写父类的createEntry方法,此方法不需要检测是否要扩充容量,
* 与HashMap中此方法的唯一区别时,这里不仅把元素插入到散列表中,
* 而且将元素插入到了链表尾
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry<K,V> old = table[bucketIndex];
Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
table[bucketIndex] = e;
e.addBefore(header);
size++;
}
/**
*
* 此方法会在调用put()或putAll()方法时调用,此方法告诉linkedHashMap
* 是否在添加一个元素后移除最老的元素
* 比如下面代码会让LinedHashMap的大小始终保持在100
* private static final int MAX_ENTRIES = 100;
*
* protected boolean removeEldestEntry(Map.Entry eldest) {
* return size() > MAX_ENTRIES;
* }
* 此方法默认返回false,需要子类去复写此方法
*
* 什么是eldest元素?
* 如果按插入问顺序来说,是map中最先插入的元素
* 如果按访问顺序来说,是map中最久未被访问的元素
*/
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
}
关于LinkedHashSet
/**
* LinkedHashSet实际上是基于LinkedHashMap的基础上实现的,
* LinkedHashSet继承自HashSet,在HashSet中有一构造方法
* HashSet(int initialCapacity, float loadFactor, boolean dummy)
* 第三个参数dummy为true时new出了一个LinkedHashMap实例,以Set中的
* 元素为键,以一个Object的虚假的对象为值,所以HashSet中的元素不可能重复。
* 以下构造函数dummy都为true
*/
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = -2851667679971038690L;
public LinkedHashSet(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor, true);
}
public LinkedHashSet(int initialCapacity) {
super(initialCapacity, .75f, true);
}
public LinkedHashSet() {
super(16, .75f, true);
}
public LinkedHashSet(Collection<? extends E> c) {
super(Math.max(2*c.size(), 11), .75f, true);
addAll(c);
}
}
集合框架源码分析五之LinkedHashMap,LinkedHashSet相关推荐
- 集合框架源码分析四(Collections类详细分析)
我认为Collections类主要是完成了两个主要功能 1.提供了若干简单而又有用的算法,比如排序,二分查找,求最大最小值等等. 2.提供对集合进行包装的静态方法.比如把指定的集合包装成线程安全的 ...
- 集合框架源码分析三(实现类篇ArrayList,LinkedList,HashMap)
一.ArrayList,可自动扩充容量的动态数组 public class ArrayList<E> extends AbstractList<E> implements Li ...
- 集合框架源码分析一(接口篇)
一.Iterable接口 public interface Iterable<T> { /** * 实现此接口的所有集合都可以使用foreach循环 * 由于Colle ...
- 集合框架源码分析六之堆结构的实现(PriorityQueue)
/** * * 优先队列是用了一种叫做堆的高效的数据结构, * 堆是用二叉树来描述的,对任意元素n,索引从0开始,如果有子节点的话,则左子树为 * 2*n+1,右子树为2*(n+1). * 以堆实现的 ...
- 集合框架源码分析——抽象类
public abstract class AbstractCollection<E> implements Collection<E> { /** * 唯一 ...
- 【java集合框架源码剖析系列】java源码剖析之ArrayList
注:博主java集合框架源码剖析系列的源码全部基于JDK1.8.0版本. 本博客将从源码角度带领大家学习关于ArrayList的知识. 一ArrayList类的定义: public class Arr ...
- 集合底层源码分析之HashMap《上》(三)
集合底层源码分析之HashMap<上>(三) 前言 源码分析 HashMap主要属性及构造方法分析 tableSizeFor()方法源码分析 Node类源码分析 TreeNode类源码分析 ...
- Android框架源码分析——从设计模式角度看 Retrofit 核心源码
Android框架源码分析--从设计模式角度看 Retrofit 核心源码 Retrofit中用到了许多常见的设计模式:代理模式.外观模式.构建者模式等.我们将从这三种设计模式入手,分析 Retrof ...
- SPI驱动框架源码分析
SPI驱动框架源码分析 2013-04-12 16:13:08 分类: LINUX SPI驱动框架源码分析 SPI协议是一种同步的串行数据连接标准,由摩托罗拉公司命名,可工作于全双工模式.相关通讯设 ...
最新文章
- python之发送HTML内容的邮件
- 攻击面管理(ASM),企业攻击面管理实践指南
- 计算机程序中断方式有几种,奥鹏离线作业计算机组成原理一、简答题1、请说明程序查询方式与中断方式各自的特点.2、提高存储器速度可采用哪些措施,请说出...
- 二叉树叶子节点迭代器
- Super详解(重点)
- 【官方活动】亲,咱简历上的精通‘微服务’您真的懂吗? 奉送21天实战微服务免费课程
- 使用lua实现nginx rewrite
- 遗忘root用户密码
- 计算机专业岗位细分及学习必备清单
- 虚拟机自动安装linux操作系统(kickstart+pxe+dhcp+tftp)
- 浅谈css中一个元素如何在其父元素居中显示
- h3c使用acl控制ftp访问_H3C交换机典型访问控制列表(ACL)配置实例
- 用手机当电脑摄像头的方法
- 蓝牙RFCOMM协议
- 节省处理HPC数据泛滥开支的可用工具
- 国家信息安全水平考试NISP考试经验分享
- 7-1 复数类的操作
- 简易社团管理系统(jsp+servlet+三件套+未完成)
- 宗镜录略讲——南怀瑾老师——系列2
- Opencascade可视化--视图渲染流程分析