Cool Jazz — Mon, 09 Aug 2010 07:14:00 GMT

HashMap是一�U�十分常用的数据�l�构�Q�作��Z��个应用开发�h员，对其原理、实现的加深理解有助于更高效地进行数据存取。本文所用的jdk版本�?.5�?

使用HashMap

《Effective JAVA》中认�ؓ�Q?9%的情况下�Q�当你覆盖了equals�Ҏ(gu��)��后，请务必覆盖hashCode�Ҏ(gu��)��。默认情况下�Q�这两者会采用Object�?#8220;原生”实现方式�Q�即�Q?

Java代码�Q?a title="复制代码" onclick="dp.sh.Toolbar.CopyToClipboard(this);return false;" >

protected native int hashCode();
public boolean equals(Object obj) {
return (this == obj);
}

protected native int hashCode();
public boolean equals(Object obj) {
return (this == obj);
}

hashCode�Ҏ(gu��)��的定义用��C��native关键字，表示它是由C或C++采用较�ؓ底层的方式来实现的，你可以认为它�q�回了该对象的内存地址�Q�而缺省equals则认为，只有当两者引用同一个对象时�Q�才认�ؓ它们是相�{�的。如果你只是覆盖了equals()而没有重新定义hashCode()�Q�在��d��HashMap的时候，除非你��用一个与你保存时引用完全相同的对象作为key��|��否则你将得不到该key所对应的倹{�?

另一斚w��Q�你应该��量避免使用“可变”的类作�ؓHashMap的键。如果你��一个对象作为键值�ƈ保存在HashMap中，之后又改变了其状态，那么HashMap��׃��产生混�ؕ�Q�你所保存的值可能丢失（��管遍历集合可能可以扑ֈ��Q�。可参�?em>http://www.ibm.com/developerworks/cn/java/j-jtp02183/

HashMap存取机制

Hashmap实际上是一个数�l�和链表的结合体�Q�利用数�l�来模拟一个个�Ӟ��c�M��于Bucket Sort�Q�以快速存取不同hashCode的key�Q�对于相同hashCode的不同key�Q�再调用其equals�Ҏ(gu��)��从List中提取出和key所相对应的value�?

JAVA中h(hu��n)ashMap的初始化主要是�ؓinitialCapacity和loadFactor�q�两个属性赋倹{��前者表�C�hashMap中用来区分不同hash值的key�I�间长度�Q�后者是指定了当hashMap中的元素��过多少的时候，开始自动扩容，。默认情况下initialCapacity�?6�Q�loadFactor�?.75�Q�它表示一开始hashMap可以存放16个不同的hashCode�Q�当填充到第12个的时候，hashMap会自动将其key�I�间的长度扩容到32�Q�以此类推；�q�点可以从源码中看出来：

Java代码�Q?/div>

void addEntry(int hash, K key, V value, int bucketIndex) {
Entry e = table[bucketIndex];
table[bucketIndex] = new Entry(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}

void addEntry(int hash, K key, V value, int bucketIndex) {
Entry e = table[bucketIndex];
table[bucketIndex] = new Entry(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}

而每当hashMap扩容后，内部的每个元素存攄��位置都会发生变化�Q�因为元素的最�l�位�|�是其hashCode对key�I�间长度取模而得�Q�，因此resize�Ҏ(gu��)��中又会调用transfer函数�Q�用来重新分配内部的元素�Q�这个过�E�成为rehash�Q�是十分消耗性能的，因此在可预知元素的个数的情况下，一般应该避免��用缺省的initialCapacity�Q�而是通过构造函��Cؓ其指定一个倹{��例如我们可能会惌��数据库查询所�?000条记录以某个特定字段�Q�比如ID�Q��ؓkey�~�存在hashMap中，��Z��提高效率、避免rehash�Q�可以直接指定initialCapacity�?048�?

另一个值得注意的地�Ҏ(gu��)��Q�hashMap其key�I�间的长度一定�ؓ2的N�ơ方�Q�这一点可以从一下源码中看出来：

Java代码�Q?/div>

int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;

int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;

即��我们在构造函��C��指定的initialCapacity不是2的��^�Ҏ(gu��)��Q�capacity�q�是会被赋��gؓ2的N�ơ方�?

��Z��么Sun Microsystem的工�E�师要将hashMap key�I�间的长度设�?的N�ơ方呢？�q�里参考R.W.Floyed�l�出的衡量散列思想的三个标准：

��Z��各元素的hashCode保存至长度�ؓLength的key数组中，一般采用取模的方式�Q�即index = hashCode % Length。不可避免的�Q�存在多个不同对象的hashCode被安排在同一位置�Q�这��是我们�q�x��所谓的“冲突”。如果仅仅是考虑元素均匀化与冲突极小化，��g��应该��Length取�ؓ素数�Q�尽��没有明昄��理论来支持这一点，但数学家们通过大量的实践得出结论，对素数取模的产生�l�果的无��x��要大于其它数字�Q�。�ؓ此，Craig Larman and Rhett Guthrie《Java Performence》中�Ҏ(gu��)��也大加抨凅R��ؓ了弄清楚�q�个问题�Q�Bruce Eckel�Q�Thinking in JAVA的作者）专程采访了java.util.hashMap的作者Joshua Bloch�Q��ƈ��他采用�q�种设计的原因放��C��|�上�Q?a target=_blank>http://www.roseindia.net/javatutorials/javahashmap.shtml�Q?�?

上述设计的原因在于，取模�q�算在包括JAVA在内的大多数语言中的效率都十分低下，而当除数�?的N�ơ方�Ӟ��取模�q�算��退化�ؓ最��单的位运��，其效率明显提升（按照Bruce Eckel�l�出的数据，大约可以提升5�?倍）。看看JDK中是如何实现的：

Java代码�Q?/div>

static int indexFor(int h, int length) {
return h & (length-1);
}

static int indexFor(int h, int length) {
return h & (length-1);
}

当key�I�间长度�?的N�ơ方�Ӟ��计算hashCode为h的元素的索引可以用简单的与操作来代替�W�拙的取模操作！假设某个对象的hashCode�?5�Q�二�q�制�?00011�Q�，而hashMap采用默认的initialCapacity�Q?6�Q�，那么indexFor计算所得结果将会是100011 & 1111 = 11�Q�即十进制的3�Q�是不是恰好�?5 Mod 16�?

上面的方法有一个问题，��是它的计算�l�果仅有对象hashCode的低位决定，而高位被�l�统屏蔽了；以上面�ؓ例，19�Q?0011�Q��?5�Q?00011�Q��?7�Q?000011�Q�等��具有相同的�l�果。针对这个问题， Joshua Bloch采用�?#8220;防�M性编�E?#8221;的解��x��法，在��用各对象的hashCode之前对其�q�行二次Hash�Q�参看JDK中的源码�Q?

Java代码�Q?/a>

static int hash(Object x) {
int h = x.hashCode();
h += ~(h << 9);
h ^= (h >>> 14);
h += (h << 4);
h ^= (h >>> 10);
return h;
}

static int hash(Object x) {
int h = x.hashCode();
h += ~(h << 9);
h ^=  (h >>> 14);
h +=  (h << 4);
h ^=  (h >>> 10);
return h;
}

采用�q�种旋�{Hash函数的主要目的是让原有hashCode的高位信息也能被充分利用�Q�且兼顾计算效率以及数据�l�计的特性，其具体的原理已超��Z��本文的领域�?

加快Hash效率的另一个有效途径是编写良好的自定义对象的HashCode�Q�String的实现采用了如下的计��方法：

Java代码�Q?/a>

for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;

for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;

�q�种�Ҏ(gu��)��HashCode的计��方法可能最早出现在Brian W. Kernighan和Dennis M. Ritchie的《The C Programming Language》中�Q�被认�ؓ是性�h(hu��n)比最高的��法�Q�又被称为times33��法�Q�因为C中乘数常量�ؓ33�Q�JAVA中改�?1�Q�，实际上，包括List在内的大多数的对象都是用�q�种�Ҏ(gu��)��计算Hash倹{�?

另一�U�比较特�D�的hash��法�U�Cؓ布隆�q��o器，它以牺牲�l�微�_�ֺ��Z��P��换来存储�I�间的大量节俭，常用于诸如判断用户名重复、是否在黑名单上�{�等�Q�可以参考李开复的数学之美�p�d��W?3��（http://googlechinablog.com/2006/08/blog-post.html�Q?

Fail-Fast机制

众所周知�Q�HashMap不是�U�程安全的集合类。但在某些容错能力较好的应用中，如果你不想仅仅因�?%的可能性而去承受hashTable的同步开销�Q�则可以考虑利用一下HashMap的Fail-Fast机制�Q�其具体实现如下�Q?

Java代码�Q?/a>

Entry nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
……
}

Entry nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
……
}

其中modCount为HashMap的一个实例变量，�q�且被声明�ؓvolatile�Q�表�C�Z�Q何线�E�都可以看到该变量被其它�U�程修改的结果（�Ҏ(gu��)��JVM内存模型的优化，每一个线�E�都会存一份自��q��工作内存�Q�此工作内存的内容与本地内存�q��时时��d��都同步，因此可能会出现线�E�间的修改不可见的问题）。��用Iterator开始�P代时�Q�会��modCount的赋值给expectedModCount�Q�在�q�代�q�程中，通过每次比较两者是否相�{�来判断HashMap是否在内部或被其它线�E�修攏V��HashMap的大多数修改�Ҏ(gu��)��都会改变ModCount�Q�参考下面的源码�Q?

Java代码�Q?/a>

public V put(K key, V value) {
K k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length);
for (Entry e = table[i]; e != null; e = e.next) {
if (e.hash == hash && eq(k, e.key)) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, k, value, i);
return null;
}

public V put(K key, V value) {
K k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length);
for (Entry e = table[i]; e != null; e = e.next) {
if (e.hash == hash && eq(k, e.key)) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, k, value, i);
return null;
}

以put�Ҏ(gu��)��Z��Q�每�ơ往HashMap中添加元素都会导致modCount自增。其它诸如remove、clear�Ҏ(gu��)��也都包含�c�M��的操作�?
从上面可以看出，HashMap所采用的Fail-Fast机制本质上是一�U�乐观锁机制�Q�通过��查状态——没有问题则忽略——有问题则抛出异常的方式�Q�来避免�U�程同步的开销�Q�下面给��Z��个在单线�E�环境下发生Fast-Fail的例子：

Java代码�Q?/a>

class Test {
public static void main(String[] args) {
java.util.HashMap map=new java.util.HashMap();
map.put(new Object(), "a");
map.put(new Object(), "b");
java.util.Iterator it=map.keySet().iterator();
while(it.hasNext()){
it.next();
map.put("", "");
System.out.println(map.size());
}
}

class Test {
public static void main(String[] args) {
java.util.HashMap map=new java.util.HashMap();
map.put(new Object(), "a");
map.put(new Object(), "b");
java.util.Iterator it=map.keySet().iterator();
while(it.hasNext()){
it.next();
map.put("", "");
System.out.println(map.size());
}
}

�q�行上面的代码会抛出java.util.ConcurrentModificationException�Q�因为在�q�代�q�程中修改了HashMap内部的元素导致modCount自增。若��上面代码中 map.put(new Object(), "b") �q�句注释掉，�E�序会顺利通过�Q�因为此时HashMap中只包含一个元素，�l�过一�ơ�P代后已到了尾部，所以不会出现问题，也就没有抛出异常的必要了�?
在通常�q�发环境下，�q�是��采用同步机制。这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在�q�样的对象，则应该��?Collections.synchronizedMap �Ҏ(gu��)��?#8220;包装”该映��。最好在创徏时完成这一操作�Q�以防止意外的非同步讉K��?

LinkedHashMap

遍历HashMap所得到的数据是杂�ؕ无章的，�q�在某些情况下客户需要特定遍历顺序时是十分有用的。比如，�q�种数据�l�构很适合构徏 LRU �~�存。调�?put �?get �Ҏ(gu��)��会讉K��相应的条目（假定调用完成后它�q�存在）。putAll �Ҏ(gu��)��以指定映��的条目集合�q�代器提供的�?值映��关�pȝ��序�Q��ؓ指定映射的每个映��关�pȝ��成一个条目访问。Sun提供的J2SE说明文档特别规定��M��其他�Ҏ(gu��)��均不生成条目讉K��Q�尤�Ӟ��collection 集合�cȝ��操作不会影响底层映射的�P代顺序�?

LinkedHashMap的实��C�� HashMap 的不同之处在于，前者维护着一个运行于所有条目的双重链接列表。此链接列表定义了�P代顺序，该�P代顺序通常��是集合中元素的插入��序。该�c�d��义了header、before与after三个属性来表示该集合类的头与前�?#8220;指针”�Q�其具体用法�c�M��于数据结构中的双链表�Q�以删除某个元素��Z��Q?

Java代码�Q?/a>

private void remove() {
before.after = after;
after.before = before;
}

private void remove() {
before.after = after;
after.before = before;
}

实际上就是改变前后指针所指向的元素�?

昄��Q�由于增加了�l�护链接列表的开支，其性能要比 HashMap �E�逊一�{�，不过有一点例外：LinkedHashMap的�P代所需旉��与其的所包含的元素成比例�Q�而HashMap �q�代旉��很可能开支较大，因�ؓ它所需要的旉��与其定w��Q�分配给Key�I�间的长度）成比例。一�a�以蔽之，随机存取用HashMap�Q�顺序存取或是遍历用LinkedHashMap�?

LinkedHashMap�q�重写了removeEldestEntry�Ҏ(gu��)��以实现自动清除过期数据的功能�Q�这在HashMap中是无法实现的，因�ؓ后者其内部的元素是无序的。默认情况下�Q�LinkedHashMap中的removeEldestEntry的作用被关闭�Q�其具体实现如下�Q?

Java代码�Q?/a>

protected boolean removeEldestEntry(Map.Entry eldest) {
return false;
}

protected boolean removeEldestEntry(Map.Entry eldest) {
return false;
}

可以使用如下的代码覆盖removeEldestEntry�Q?

Java代码�Q?/a>

private static final int MAX_ENTRIES = 100;
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > MAX_ENTRIES;
}

private static final int MAX_ENTRIES = 100;
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > MAX_ENTRIES;
}

它表�C�，刚开始，LinkedHashMap中的元素不断增长�Q�当它内部的元素��过MAX_ENTRIES�Q?00�Q�后�Q�每当有新的元素被插入时�Q�都会自动删除双链表中最前端�Q�最旧）的元素，从而保持LinkedHashMap的长度稳定�?

�~�省情况下，LinkedHashMap采取的更新策略是�c�M��于队列的FIFO�Q�如果你惛_��现更复杂的更新逻辑比如LRU�Q�最�q�最��用） �{�，可以在构造函��C��指定其accessOrder为true�Q�因为的讉K��元素的方法（get�Q�内部会调用一�?#8220;钩子”�Q�即recordAccess�Q�其具体实现如下�Q?

Java代码�Q?/a>

void recordAccess(HashMap m) {
LinkedHashMap lm = (LinkedHashMap)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}

void recordAccess(HashMap m) {
LinkedHashMap lm = (LinkedHashMap)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}

上述代码主要实现了这��L��功能�Q�如果accessOrder被设�|��ؓtrue�Q�则每次讉K��元素�Ӟ��都将该元素移至headr的前面，即链表的��N��。将removeEldestEntry与accessOrder一起��用，��可以实现最基本的内存缓存，具体代码可参�?a target=_blank>http://bluepopopo.javaeye.com/blog/180236�?

WeakHashMap

99%的JAVA教材教导我们不要��d��预JVM的垃圑֛�收机�Ӟ��但JAVA中确实存在着与其密切相关的四�U�引用：强引用、��Y引用、弱引用以及�q�象引用�?

JAVA中默认的HashMap采用的是采用�c�M��于强引用的强键来��理的，�q�意味着即��作�ؓkey的对象已�l�不存在了（指没有�Q何一个引用指向它�Q�，也仍然会保留在HashMap中，在某些情况下�Q�例如内存缓存）中，�q�些�q�期的条目可能会造成内存泄漏�{�问题�?

WeakHashMap采用的策略是�Q�只要作为key的对象已�l�不存在了（��出生命周期�Q�，��׃��会阻止垃圾收集器清空此条目，即��当前机器的内存�ƈ不紧张。不�q�，�׃��GC是一个优先��很低的线�E�，因此不一定会很快发现那些只具有弱引用的对象，除非你显�C�地调用它，可以参考下面的例子�Q?

Java代码�Q?/a>

public static void main(String[] args) {
Mapmap = new WeakHashMap();
map.put(new String("Alibaba"), "alibaba");
while (map.containsKey("Alibaba")) {
try {
Thread.sleep(500);
} catch (InterruptedException ignored) {
}
System.out.println("Checking for empty");
System.gc();
}

public static void main(String[] args) {
Mapmap = new WeakHashMap();
map.put(new String("Alibaba"), "alibaba");
while (map.containsKey("Alibaba")) {
try {
Thread.sleep(500);
} catch (InterruptedException ignored) {
}
System.out.println("Checking for empty");
System.gc();
}

上述代码输出一�ơChecking for empty��退��Z��ȝ��E�，意味着GC在最�q�的一�ơ垃圑֛�收周期中清除了new String(“Alibaba”),同时WeakHashMap也做��Z��及时的反应，��该键对应的条目删除了。如果将map的类型改为HashMap的话�Q�由于其内部采用的是强引用机�Ӟ��因此即��GC被显�C��用，map中的条目依然存在�Q�程序会不断地打出Checking for empty字样。另外，在��用WeakHashMap的情况下�Q�若是将

Java代码�Q?/a>

map.put(new String("Alibaba"), "alibaba");

map.put(new String("Alibaba"), "alibaba");

改�ؓ

Java代码�Q?/a>

map.put("Alibaba", "alibaba");

map.put("Alibaba", "alibaba");

�E�序�q�是会不断输出Checking for empty。这与前面我们分析的WeakHashMap的弱引用机制�q�不矛盾�Q�因为JVM��Z��减小重复创徏和维护多个相同String的开销�Q�其内部采用了蝇量模式（《JAVA与模式》）�Q�此时的“Alibaba”是存攑֜�帔R��池而非堆中的，因此即��没有对象指向“Alibaba”�Q�它也不会被GC回收。弱引用特别适合以下对象�Q�占用大量内存，但通过垃圾回收功能回收以后很容易重新创建�?

介于HashMap和WeakHashMap之中的是SoftHashMap�Q�它所采用的��Y引用的策略指的是�Q�垃圾收集器�q�不像其攉��弱可及的对象一样尽量地攉��软可及的对象�Q�相反，它只在真�?“需�?#8221; 内存时才攉��软可及的对象。��Y引用对于垃圾攉��器来说是一�U?#8220;睁一只眼�Q�闭一只眼”方式�Q�即 “只要内存不太紧张�Q�我��׃��保留该对象。但是如果内存变得真正紧张了�Q�我��׃��L��集�ƈ处理�q�个对象�?#8221; ��p��一点看�Q�它其实要比WeakHashMap更适合于实现缓存机制。遗憄��是，JAVA中�ƈ没有实现相关的SoftHashMap�c�（Apache和Google提供了第三方的实玎ͼ��Q�但它却是提供了两个十分重要的类java.lang.ref.SoftReference以及ReferenceQueue�Q�可以在对象应用状态发生改变是得到通知�Q�可以参考com.alibaba.common.collection.SofthashMap中processQueue�Ҏ(gu��)��的实�?

Java代码�Q?/a>

private ReferenceQueue queue = new ReferenceQueue();
ValueCell vc;
Map hash = new HashMap(initialCapacity, loadFactor);
……
while ((vc = (ValueCell) queue.poll()) != null) {
if (vc.isValid()) {
hash.remove(vc.key);
} else {
valueCell.dropped--;
}
}
}

private ReferenceQueue queue = new ReferenceQueue();
ValueCell vc;
Map hash = new HashMap(initialCapacity, loadFactor);
……
while ((vc = (ValueCell) queue.poll()) != null) {
if (vc.isValid()) {
hash.remove(vc.key);
} else {
valueCell.dropped--;
}
}
}

processQueue�Ҏ(gu��)��会在几乎所有SoftHashMap的方法中被调用到�Q�JVM会通过ReferenceQueue的poll�Ҏ(gu��)��通知该对象已�l�过期�ƈ且当前的内存现状需要将它释放，此时我们��可以将其从hashMap中剔除。事实上�Q�默认情况下�Q�Alibaba的MemoryCache所使用的就是SoftHashMap�?

来源�Q?a >http://grunt1223.javaeye.com/blog/544497

Cool Jazz 2010-08-09 15:14 发表评论

蜜桃精品视频在线观看,中文字幕中文字幕中文字幕亚洲无线 ,中文字幕一区二区三区四区五区