爱游戏全站app官网入口-爱游戏官网

java 集合系列14之 map总结(hashmap, hashtable, treemap, weakhashmap等使用场景) -爱游戏全站app官网入口

2023-09-02,,

概要

学完了map的全部内容,我们再回头开开map的框架图。

本章内容包括:
第1部分 map概括
第2部分 hashmap和hashtable异同
第3部分 hashmap和weakhashmap异同

转载请注明出处:http://www.cnblogs.com/skywang12345/admin/editposts.aspx?postid=3311126

第1部分 map概括

(01) map 是“键值对”映射的抽象接口。
(02) abstractmap 实现了map中的绝大部分函数接口。它减少了“map的实现类”的重复编码。
(03) sortedmap 有序的“键值对”映射接口。
(04) navigablemap 是继承于sortedmap的,支持导航函数的接口。
(05) hashmap, hashtable, treemap, weakhashmap这4个类是“键值对”映射的实现类。它们各有区别!

  hashmap 是基于“拉链法”实现的散列表。一般用于单线程程序中。
  hashtable 也是基于“拉链法”实现的散列表。它一般用于多线程程序中。
  weakhashmap 也是基于“拉链法”实现的散列表,它一般也用于单线程程序中。相比hashmap,weakhashmap中的键是“弱键”,当“弱键”被gc回收时,它对应的键值对也会被从weakhashmap中删除;而hashmap中的键是强键。
  treemap 是有序的散列表,它是通过红黑树实现的。它一般用于单线程中存储有序的映射。

第2部分 hashmap和hashtable异同

第2.1部分 hashmap和hashtable的相同点

hashmaphashtable都是存储“键值对(key-value)”的散列表,而且都是采用拉链法实现的。
存储的思想都是:通过table数组存储,数组的每一个元素都是一个entry;而一个entry就是一个单向链表entry链表中的每一个节点就保存了key-value键值对数据

添加key-value键值对:首先,根据key值计算出哈希值,再计算出数组索引(即,该key-value在table中的索引)。然后,根据数组索引找到entry(即,单向链表),再遍历单向链表,将key和链表中的每一个节点的key进行对比。若key已经存在entry链表中,则用该value值取代旧的value值;若key不存在entry链表中,则新建一个key-value节点,并将该节点插入entry链表的表头位置。
删除key-value键值对:删除键值对,相比于“添加键值对”来说,简单很多。首先,还是根据key计算出哈希值,再计算出数组索引(即,该key-value在table中的索引)。然后,根据索引找出entry(即,单向链表)。若节点key-value存在与链表entry中,则删除链表中的节点即可。

上面介绍了hashmap和hashtable的相同点。正是由于它们都是散列表,我们关注更多的是“它们的区别,以及它们分别适合在什么情况下使用”。那接下来,我们先看看它们的区别。

第2.2部分 hashmap和hashtable的不同点

1 继承和实现方式不同

hashmap 继承于abstractmap,实现了map、cloneable、java.io.serializable接口。
hashtable 继承于dictionary,实现了map、cloneable、java.io.serializable接口。

hashmap的定义:

public class hashmap
extends abstractmap
implements map, cloneable, serializable { ... }

hashtable的定义:

public class hashtable
extends dictionary
implements map, cloneable, java.io.serializable { ... }

从中,我们可以看出:
1.1 hashmap和hashtable都实现了map、cloneable、java.io.serializable接口。
      实现了map接口,意味着它们都支持key-value键值对操作。支持“添加key-value键值对”、“获取key”、“获取value”、“获取map大小”、“清空map”等基本的key-value键值对操作。
      实现了cloneable接口,意味着它能被克隆。
      实现了java.io.serializable接口,意味着它们支持序列化,能通过序列化去传输。

1.2 hashmap继承于abstractmap,而hashtable继承于dictionary
      dictionary是一个抽象类,它直接继承于object类,没有实现任何接口。dictionary类是jdk 1.0的引入的。虽然dictionary也支持“添加key-value键值对”、“获取value”、“获取大小”等基本操作,但它的api函数比map少;而且             dictionary一般是通过enumeration(枚举类)去遍历,map则是通过iterator(迭代器)去遍历。 然而‘由于hashtable也实现了map接口,所以,它即支持enumeration遍历,也支持iterator遍历。关于这点,后面还会进一步说明。
      abstractmap是一个抽象类,它实现了map接口的绝大部分api函数;为map的具体实现类提供了极大的便利。它是jdk 1.2新增的类。

2 线程安全不同

hashtable的几乎所有函数都是同步的,即它是线程安全的,支持多线程。
而hashmap的函数则是非同步的,它不是线程安全的。若要在多线程中使用hashmap,需要我们额外的进行同步处理。 对hashmap的同步处理可以使用collections类提供的synchronizedmap静态方法,或者直接使用jdk 5.0之后提供的java.util.concurrent包里的concurrenthashmap类。

3 对null值的处理不同

hashmap的key、value都可以为null
hashtable的key、value都不可以为null

我们先看看hashmap和hashtable “添加key-value”的方法

hashmap的添加key-value的方法

 // 将“key-value”添加到hashmap中
public v put(k key, v value) {
// 若“key为null”,则将该键值对添加到table[0]中。
if (key == null)
return putfornullkey(value);
// 若“key不为null”,则计算该key的哈希值,然后将其添加到该哈希值对应的链表中。
int hash = hash(key.hashcode());
int i = indexfor(hash, table.length);
for (entry e = table[i]; e != null; e = e.next) {
object k;
// 若“该key”对应的键值对已经存在,则用新的value取代旧的value。然后退出!
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
v oldvalue = e.value;
e.value = value;
e.recordaccess(this);
return oldvalue;
}
} // 若“该key”对应的键值对不存在,则将“key-value”添加到table中
modcount ;
addentry(hash, key, value, i);
return null;
} // putfornullkey()的作用是将“key为null”键值对添加到table[0]位置
private v putfornullkey(v value) {
for (entry e = table[0]; e != null; e = e.next) {
if (e.key == null) {
v oldvalue = e.value;
e.value = value;
// recordaccess()函数什么也没有做
e.recordaccess(this);
return oldvalue;
}
}
// 添加第1个“key为null”的元素都table中的时候,会执行到这里。
// 它的作用是将“设置table[0]的key为null,值为value”。
modcount ;
addentry(0, null, value, 0);
return null;
}

hashtable的添加key-value的方法

 // 将“key-value”添加到hashtable中
public synchronized v put(k key, v value) {
// hashtable中不能插入value为null的元素!!!
if (value == null) {
throw new nullpointerexception();
} // 若“hashtable中已存在键为key的键值对”,
// 则用“新的value”替换“旧的value”
entry tab[] = table;
// hashtable中不能插入key为null的元素!!!
// 否则,下面的语句会抛出异常!
int hash = key.hashcode();
int index = (hash & 0x7fffffff) % tab.length;
for (entry e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
v old = e.value;
e.value = value;
return old;
}
} // 若“hashtable中不存在键为key的键值对”,
// (01) 将“修改统计数” 1
modcount ;
// (02) 若“hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
// 则调整hashtable的大小
if (count >= threshold) {
// rehash the table if the threshold is exceeded
rehash(); tab = table;
index = (hash & 0x7fffffff) % tab.length;
} // (03) 将“hashtable中index”位置的entry(链表)保存到e中 entry e = tab[index];
// (04) 创建“新的entry节点”,并将“新的entry”插入“hashtable的index位置”,并设置e为“新的entry”的下一个元素(即“新entry”为链表表头)。
tab[index] = new entry(hash, key, value, e);
// (05) 将“hashtable的实际容量” 1
count ;
return null;
}

根据上面的代码,我们可以看出:

hashtable的key或value,都不能为null!否则,会抛出异常nullpointerexception。
hashmap的key、value都可以为null。 当hashmap的key为null时,hashmap会将其固定的插入table[0]位置(即hashmap散列表的第一个位置);而且table[0]处只会容纳一个key为null的值,当有多个key为null的值插入的时候,table[0]会保留最后插入的value。

4 支持的遍历种类不同

hashmap只支持iterator(迭代器)遍历。
而hashtable支持iterator(迭代器)和enumeration(枚举器)两种方式遍历。

enumeration 是jdk 1.0添加的接口,只有hasmoreelements(), nextelement() 两个api接口,不能通过enumeration()对元素进行修改 。
而iterator 是jdk 1.2才添加的接口,支持hasnext(), next(), remove() 三个api接口。hashmap也是jdk 1.2版本才添加的,所以用iterator取代enumeration,hashmap只支持iterator遍历。

5 通过iterator迭代器遍历时,遍历的顺序不同

hashmap是“从前向后”的遍历数组;再对数组具体某一项对应的链表,从表头开始进行遍历。
hashtabl是“从后往前”的遍历数组;再对数组具体某一项对应的链表,从表头开始进行遍历。

hashmap和hashtable都实现map接口,所以支持获取它们“key的集合”、“value的集合”、“key-value的集合”,然后通过iterator对这些集合进行遍历。
由于“key的集合”、“value的集合”、“key-value的集合”的遍历原理都是一样的;下面,我以遍历“key-value的集合”来进行说明。

hashmap 和hashtable 遍历"key-value集合"的方式是:(01) 通过entryset()获取“map.entry集合”。 (02) 通过iterator()获取“map.entry集合”的迭代器,再进行遍历。

hashmap的实现方式:先“从前向后”的遍历数组;对数组具体某一项对应的链表,则从表头开始往后遍历。

 // 返回“hashmap的entry集合”
public set> entryset() {
return entryset0();
}
// 返回“hashmap的entry集合”,它实际是返回一个entryset对象
private set> entryset0() {
set> es = entryset;
return es != null ? es : (entryset = new entryset());
}
// entryset对应的集合
// entryset继承于abstractset,说明该集合中没有重复的entryset。
private final class entryset extends abstractset> {
...
public iterator> iterator() {
return newentryiterator();
}
...
}
// 返回一个“entry迭代器”
iterator> newentryiterator() {
return new entryiterator();
}
// entry的迭代器
private final class entryiterator extends hashiterator> {
public map.entry next() {
return nextentry();
}
}
private abstract class hashiterator implements iterator {
// 下一个元素
entry next;
// expectedmodcount用于实现fail-fast机制。
int expectedmodcount;
// 当前索引
int index;
// 当前元素
entry current; hashiterator() {
expectedmodcount = modcount;
if (size > 0) { // advance to first entry
entry[] t = table;
// 将next指向table中第一个不为null的元素。
// 这里利用了index的初始值为0,从0开始依次向后遍历,直到找到不为null的元素就退出循环。
while (index < t.length && (next = t[index ]) == null)
;
}
} public final boolean hasnext() {
return next != null;
} // 获取下一个元素
final entry nextentry() {
if (modcount != expectedmodcount)
throw new concurrentmodificationexception();
entry e = next;
if (e == null)
throw new nosuchelementexception(); // 注意!!!
// 一个entry就是一个单向链表
// 若该entry的下一个节点不为空,就将next指向下一个节点;
// 否则,将next指向下一个链表(也是下一个entry)的不为null的节点。
if ((next = e.next) == null) {
entry[] t = table;
while (index < t.length && (next = t[index ]) == null)
;
}
current = e;
return e;
} ...
}

hashtable的实现方式:先从“后向往前”的遍历数组;对数组具体某一项对应的链表,则从表头开始往后遍历。

 public set> entryset() {
if (entryset==null)
entryset = collections.synchronizedset(new entryset(), this);
return entryset;
} private class entryset extends abstractset> {
public iterator> iterator() {
return getiterator(entries);
}
...
} private class enumerator implements enumeration, iterator {
// 指向hashtable的table
entry[] table = hashtable.this.table;
// hashtable的总的大小
int index = table.length;
entry entry = null;
entry lastreturned = null;
int type; // enumerator是 “迭代器(iterator)” 还是 “枚举类(enumeration)”的标志
// iterator为true,表示它是迭代器;否则,是枚举类。
boolean iterator; // 在将enumerator当作迭代器使用时会用到,用来实现fail-fast机制。
protected int expectedmodcount = modcount; enumerator(int type, boolean iterator) {
this.type = type;
this.iterator = iterator;
} // 从遍历table的数组的末尾向前查找,直到找到不为null的entry。
public boolean hasmoreelements() {
entry e = entry;
int i = index;
entry[] t = table;
/* use locals for faster loop iteration */
while (e == null && i > 0) {
e = t[--i];
}
entry = e;
index = i;
return e != null;
} // 获取下一个元素
// 注意:从hasmoreelements() 和nextelement() 可以看出“hashtable的elements()遍历方式”
// 首先,从后向前的遍历table数组。table数组的每个节点都是一个单向链表(entry)。
// 然后,依次向后遍历单向链表entry。
public t nextelement() {
entry et = entry;
int i = index;
entry[] t = table;
/* use locals for faster loop iteration */
while (et == null && i > 0) {
et = t[--i];
}
entry = et;
index = i;
if (et != null) {
entry e = lastreturned = entry;
entry = e.next;
return type == keys ? (t)e.key : (type == values ? (t)e.value : (t)e);
}
throw new nosuchelementexception("hashtable enumerator");
} // 迭代器iterator的判断是否存在下一个元素
// 实际上,它是调用的hasmoreelements()
public boolean hasnext() {
return hasmoreelements();
} // 迭代器获取下一个元素
// 实际上,它是调用的nextelement()
public t next() {
if (modcount != expectedmodcount)
throw new concurrentmodificationexception();
return nextelement();
} ... }

6 容量的初始值 和 增加方式都不一样

hashmap默认的容量大小是16;增加容量时,每次将容量变为“原始容量x2”
hashtable默认的容量大小是11;增加容量时,每次将容量变为“原始容量x2 1”。

hashmap默认的“加载因子”是0.75, 默认的容量大小是16。

 // 默认的初始容量是16,必须是2的幂。
static final int default_initial_capacity = 16; // 默认加载因子
static final float default_load_factor = 0.75f; // 指定“容量大小”的构造函数
public hashmap(int initialcapacity) {
this(initialcapacity, default_load_factor);
}

当hashmap的 “实际容量” >= “阈值”时,(阈值 = 总的容量 * 加载因子),就将hashmap的容量翻倍。

 // 新增entry。将“key-value”插入指定位置,bucketindex是位置索引。
void addentry(int hash, k key, v value, int bucketindex) {
// 保存“bucketindex”位置的值到“e”中
entry e = table[bucketindex];
// 设置“bucketindex”位置的元素为“新entry”,
// 设置“e”为“新entry的下一个节点”
table[bucketindex] = new entry(hash, key, value, e);
// 若hashmap的实际大小 不小于 “阈值”,则调整hashmap的大小
if (size >= threshold)
resize(2 * table.length);
}

hashtable默认的“加载因子”是0.75, 默认的容量大小是11。

 // 默认构造函数。
public hashtable() {
// 默认构造函数,指定的容量大小是11;加载因子是0.75
this(11, 0.75f);
}

当hashtable的 “实际容量” >= “阈值”时,(阈值 = 总的容量 x 加载因子),就将变为“原始容量x2 1”。

 // 调整hashtable的长度,将长度变成原来的(2倍 1)
// (01) 将“旧的entry数组”赋值给一个临时变量。
// (02) 创建一个“新的entry数组”,并赋值给“旧的entry数组”
// (03) 将“hashtable”中的全部元素依次添加到“新的entry数组”中
protected void rehash() {
int oldcapacity = table.length;
entry[] oldmap = table; int newcapacity = oldcapacity * 2 1;
entry[] newmap = new entry[newcapacity]; modcount ;
threshold = (int)(newcapacity * loadfactor);
table = newmap; for (int i = oldcapacity ; i-- > 0 ;) {
for (entry old = oldmap[i] ; old != null ; ) {
entry e = old;
old = old.next; int index = (e.hash & 0x7fffffff) % newcapacity;
e.next = newmap[index];
newmap[index] = e;
}
}
}

7 添加key-value时的hash值算法不同

hashmap添加元素时,是使用自定义的哈希算法。
hashtable没有自定义哈希算法,而直接采用的key的hashcode()。

hashmap添加元素时,是使用自定义的哈希算法。

 static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
} // 将“key-value”添加到hashmap中
public v put(k key, v value) {
// 若“key为null”,则将该键值对添加到table[0]中。
if (key == null)
return putfornullkey(value);
// 若“key不为null”,则计算该key的哈希值,然后将其添加到该哈希值对应的链表中。
int hash = hash(key.hashcode());
int i = indexfor(hash, table.length);
for (entry e = table[i]; e != null; e = e.next) {
object k;
// 若“该key”对应的键值对已经存在,则用新的value取代旧的value。然后退出!
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
v oldvalue = e.value;
e.value = value;
e.recordaccess(this);
return oldvalue;
}
} // 若“该key”对应的键值对不存在,则将“key-value”添加到table中
modcount ;
addentry(hash, key, value, i);
return null;
}

hashtable没有自定义哈希算法,而直接采用的key的hashcode()。

 public synchronized v put(k key, v value) {
// hashtable中不能插入value为null的元素!!!
if (value == null) {
throw new nullpointerexception();
} // 若“hashtable中已存在键为key的键值对”,
// 则用“新的value”替换“旧的value”
entry tab[] = table;
int hash = key.hashcode();
int index = (hash & 0x7fffffff) % tab.length;
for (entry e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
v old = e.value;
e.value = value;
return old;
}
} // 若“hashtable中不存在键为key的键值对”,
// (01) 将“修改统计数” 1
modcount ;
// (02) 若“hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
// 则调整hashtable的大小
if (count >= threshold) {
// rehash the table if the threshold is exceeded
rehash(); tab = table;
index = (hash & 0x7fffffff) % tab.length;
} // (03) 将“hashtable中index”位置的entry(链表)保存到e中
entry e = tab[index];
// (04) 创建“新的entry节点”,并将“新的entry”插入“hashtable的index位置”,并设置e为“新的entry”的下一个元素(即“新entry”为链表表头)。
tab[index] = new entry(hash, key, value, e);
// (05) 将“hashtable的实际容量” 1
count ;
return null;
}

8 部分api不同

hashtable支持contains(object value)方法,而且重写了tostring()方法
而hashmap不支持contains(object value)方法,没有重写tostring()方法。

最后,再说说“hashmap和hashtable”使用的情景。
其实,若了解它们之间的不同之处后,可以很容易的区分根据情况进行取舍。例如:(01) 若在单线程中,我们往往会选择hashmap;而在多线程中,则会选择hashtable。(02),若不能插入null元素,则选择hashtable;否则,可以选择hashmap。
但这个不是绝对的标准。例如,在多线程中,我们可以自己对hashmap进行同步,也可以选择concurrenthashmap。当hashmap和hashtable都不能满足自己的需求时,还可以考虑新定义一个类,继承或重新实现散列表;当然,一般情况下是不需要的了。

第3部分 hashmap和weakhashmap异同

3.1 hashmap和weakhashmap的相同点

1 它们都是散列表,存储的是“键值对”映射。
2 它们都继承于abstractmap,并且实现map基础。
3 它们的构造函数都一样。
   它们都包括4个构造函数,而且函数的参数都一样。
4 默认的容量大小是16,默认的加载因子是0.75。
5 它们的“键”和“值”都允许为null。
6 它们都是“非同步的”。

3.2 hashmap和weakhashmap的不同点

1 hashmap实现了cloneable和serializable接口,而weakhashmap没有。
   hashmap实现cloneable,意味着它能通过clone()克隆自己。
   hashmap实现serializable,意味着它支持序列化,能通过序列化去传输。

2 hashmap的“键”是“强引用(strongreference)”,而weakhashmap的键是“弱引用(weakreference)”。
   weakreference的“弱键”能实现weakreference对“键值对”的动态回收。当“弱键”不再被使用到时,gc会回收它,weakreference也会将“弱键”对应的键值对删除。
   这个“弱键”实现的动态回收“键值对”的原理呢?其实,通过weakreference(弱引用)和referencequeue(引用队列)实现的。 首先,我们需要了解weakhashmap中:
    第一,“键”是weakreference,即key是弱键。
    第二,referencequeue是一个引用队列,它是和weakhashmap联合使用的。当弱引用所引用的对象被垃圾回收,java虚拟机就会把这个弱引用加入到与之关联的引用队列中。 weakhashmap中的referencequeue是queue。
   第三,weakhashmap是通过数组实现的,我们假设这个数组是table。

接下来,说说“动态回收”的步骤。

(01) 新建weakhashmap,将“键值对”添加到weakhashmap中。
        将“键值对”添加到weakhashmap中时,添加的键都是弱键。
        实际上,weakhashmap是通过数组table保存entry(键值对);每一个entry实际上是一个单向链表,即entry是键值对链表。
(02) 当某“弱键”不再被其它对象引用,并被gc回收时。在gc回收该“弱键”时,这个“弱键”也同时会被添加到queue队列中。
        例如,当我们在将“弱键”key添加到weakhashmap之后;后来将key设为null。这时,便没有外部外部对象再引用该了key。
        接着,当java虚拟机的gc回收内存时,会回收key的相关内存;同时,将key添加到queue队列中。
(03) 当下一次我们需要操作weakhashmap时,会先同步table和queue。table中保存了全部的键值对,而queue中保存被gc回收的“弱键”;同步它们,就是删除table中被gc回收的“弱键”对应的键值对。
        例如,当我们“读取weakhashmap中的元素或获取weakreference的大小时”,它会先同步table和queue,目的是“删除table中被gc回收的‘弱键’对应的键值对”。删除的方法就是逐个比较“table中元素的‘键’和queue中的‘键’”,若它们相当,则删除“table中的该键值对”。

3.3 hashmap和weakhashmap的比较测试程序

 import java.util.hashmap;
import java.util.iterator;
import java.util.map;
import java.util.weakhashmap;
import java.util.date;
import java.lang.ref.weakreference; /**
* @desc hashmap 和 weakhashmap比较程序
*
* @author skywang
* @email kuiwu-wang@163.com
*/
public class comparehashmapandweakhashmap { public static void main(string[] args) throws exception { // 当“弱键”是string时,比较hashmap和weakhashmap
comparewithstring();
// 当“弱键”是自定义类型时,比较hashmap和weakhashmap
comparewithselfclass();
} /**
* 遍历map,并打印map的大小
*/
private static void iteratorandcountmap(map map) {
// 遍历map
for (iterator iter = map.entryset().iterator();
iter.hasnext(); ) {
map.entry en = (map.entry)iter.next();
system.out.printf("map entry : %s - %s\n ",en.getkey(), en.getvalue());
} // 打印hashmap的实际大小
system.out.printf(" map size:%s\n\n", map.size());
} /**
* 通过string对象测试hashmap和weakhashmap
*/
private static void comparewithstring() {
// 新建4个string字符串
string w1 = new string("w1");
string w2 = new string("w2");
string h1 = new string("h1");
string h2 = new string("h2"); // 新建 weakhashmap对象,并将w1,w2添加到 weakhashmap中
map wmap = new weakhashmap();
wmap.put(w1, "w1");
wmap.put(w2, "w2"); // 新建 hashmap对象,并将h1,h2添加到 weakhashmap中
map hmap = new hashmap();
hmap.put(h1, "h1");
hmap.put(h2, "h2"); // 删除hashmap中的“h1”。
// 结果:删除“h1”之后,hashmap中只有 h2 !
hmap.remove(h1); // 将weakhashmap中的w1设置null,并执行gc()。系统会回收w1
// 结果:w1是“弱键”,被gc回收后,weakhashmap中w1对应的键值对,也会被从weakhashmap中删除。
// w2是“弱键”,但它不是null,不会被gc回收;也就不会被从weakhashmap中删除。
// 因此,weakhashmap中只有 w2
// 注意:若去掉“w1=null” 或者“system.gc()”,结果都会不一样!
w1 = null;
system.gc(); // 遍历并打印hashmap的大小
system.out.printf(" -- hashmap --\n");
iteratorandcountmap(hmap); // 遍历并打印weakhashmap的大小
system.out.printf(" -- weakhashmap --\n");
iteratorandcountmap(wmap);
} /**
* 通过自定义类测试hashmap和weakhashmap
*/
private static void comparewithselfclass() {
// 新建4个自定义对象
self s1 = new self(10);
self s2 = new self(20);
self s3 = new self(30);
self s4 = new self(40); // 新建 weakhashmap对象,并将s1,s2添加到 weakhashmap中
map wmap = new weakhashmap();
wmap.put(s1, "s1");
wmap.put(s2, "s2"); // 新建 hashmap对象,并将s3,s4添加到 weakhashmap中
map hmap = new hashmap();
hmap.put(s3, "s3");
hmap.put(s4, "s4"); // 删除hashmap中的s3。
// 结果:删除s3之后,hashmap中只有 s4 !
hmap.remove(s3); // 将weakhashmap中的s1设置null,并执行gc()。系统会回收w1
// 结果:s1是“弱键”,被gc回收后,weakhashmap中s1对应的键值对,也会被从weakhashmap中删除。
// w2是“弱键”,但它不是null,不会被gc回收;也就不会被从weakhashmap中删除。
// 因此,weakhashmap中只有 s2
// 注意:若去掉“s1=null” 或者“system.gc()”,结果都会不一样!
s1 = null;
system.gc(); /*
// 休眠500ms
try {
thread.sleep(500);
} catch (interruptedexception e) {
e.printstacktrace();
}
// */ // 遍历并打印hashmap的大小
system.out.printf(" -- self-def hashmap --\n");
iteratorandcountmap(hmap); // 遍历并打印weakhashmap的大小
system.out.printf(" -- self-def weakhashmap --\n");
iteratorandcountmap(wmap);
} private static class self {
int id; public self(int id) {
this.id = id;
} // 覆盖finalize()方法
// 在gc回收时会被执行
protected void finalize() throws throwable {
super.finalize();
system.out.printf("gc self: id=%d addr=0x%s)\n", id, this);
}
}
}

运行结果:

 -- hashmap --
map entry : h2 - h2
map size:1 -- weakhashmap --
map entry : w2 - w2
map size:1 -- self-def hashmap --
map entry : comparehashmapandweakhashmap$self@1ff9dc36 - s4
map size:1 -- self-def weakhashmap --
gc self: id=10 addr=0xcomparehashmapandweakhashmap$self@12276af2)
map entry : comparehashmapandweakhashmap$self@59de3f2d - s2
map size:1

更多内容

01. java 集合系列10之 hashmap详细介绍(源码解析)和使用示例

02. java 集合系列11之 hashtable详细介绍(源码解析)和使用示例

03. java 集合系列12之 treemap详细介绍(源码解析)和使用示例

04. java 集合系列13之 weakhashmap详细介绍(源码解析)和使用示例

05. java 集合系列14之 map总结(hashmap, hashtable, treemap, weakhashmap等使用场景)

java 集合系列14之 map总结(hashmap, hashtable, treemap, weakhashmap等使用场景)的相关教程结束。

网站地图