Java 集合系列14之 Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)

最新推荐文章于 2024-03-18 11:01:25 发布
最新推荐文章于 2024-03-18 11:01:25 发布
阅读量544 收藏 2
点赞数
分类专栏： My框架知识点 文章标签： java 框架 Map 编程 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43652793/article/details/84780460
版权

概要
学完了Map的全部内容，我们再回头开开Map的框架图。
在这里插入图片描述
本章内容包括：
第1部分 Map概括
第2部分 HashMap和Hashtable异同
第3部分 HashMap和WeakHashMap异同

第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的相同点

HashMap和Hashtable都是存储“键值对(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<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable { … }
Hashtable的定义:

public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, 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<K,V> 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<K,V> 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<K,V> 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<K,V> e = tab[index];
    // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。        
    tab[index] = new Entry<K,V>(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<Map.Entry<K,V>> entrySet() {
    return entrySet0();
}
// 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象
private Set<Map.Entry<K,V>> entrySet0() {
    Set<Map.Entry<K,V>> es = entrySet;
    return es != null ? es : (entrySet = new EntrySet());
}
// EntrySet对应的集合
// EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    ...
    public Iterator<Map.Entry<K,V>> iterator() {
        return newEntryIterator();
    }
    ...
}
// 返回一个“entry迭代器”
Iterator<Map.Entry<K,V>> newEntryIterator()   {
    return new EntryIterator();
}
// Entry的迭代器
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
    public Map.Entry<K,V> next() {
        return nextEntry();
    }
}
private abstract class HashIterator<E> implements Iterator<E> {
    // 下一个元素
    Entry<K,V> next;
    // expectedModCount用于实现fail-fast机制。
    int expectedModCount;
    // 当前索引
    int index;
    // 当前元素
    Entry<K,V> 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<K,V> nextEntry() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        Entry<K,V> 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<Map.Entry<K,V>> entrySet() {
    if (entrySet==null)
        entrySet = Collections.synchronizedSet(new EntrySet(), this);
    return entrySet;
}

private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public Iterator<Map.Entry<K,V>> iterator() {
        return getIterator(ENTRIES);
    }
    ...
}

private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
    // 指向Hashtable的table
    Entry[] table = Hashtable.this.table;
    // Hashtable的总的大小
    int index = table.length;
    Entry<K,V> entry = null;
    Entry<K,V> 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<K,V> 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<K,V> 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<K,V> 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<K,V> e = table[bucketIndex];
    // 设置“bucketIndex”位置的元素为“新Entry”，
    // 设置“e”为“新Entry的下一个节点”
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小
    if (size++ >= threshold)
        resize(2 * table.length);
}

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

1 // 默认构造函数。
2 public Hashtable() {
3 // 默认构造函数，指定的容量大小是11；加载因子是0.75
4 this(11, 0.75f);
5 }

当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<K,V> old = oldMap[i] ; old != null ; ) {
            Entry<K,V> 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<K,V> 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<K,V> 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<K,V> e = tab[index];
    // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。        
    tab[index] = new Entry<K,V>(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 S e l f @ 1 f f 9 d c 36 − s 4 m a p s i z e : 1 − − S e l f − d e f W e a k H a s h M a p − − G C S e l f : i d = 10 a d d r = 0 x C o m p a r e H a s h m a p A n d W e a k h a s h m a p Self@1ff9dc36 - s4 map size:1 -- Self-def WeakHashMap -- GC Self: id=10 addr=0xCompareHashmapAndWeakhashmap Self@1ff9dc36−s4mapsize:1−−Self−defWeakHashMap−−GCSelf:id=10addr=0xCompareHashmapAndWeakhashmapSelf@12276af2)
map entry : CompareHashmapAndWeakhashmap$Self@59de3f2d - s2
map size:1

对编程感兴趣的朋友可以一起交流交流！禁止一切招生，广告！抠Q裙：947405150 欢迎在群内多多活跃活跃，不容易了 再次谢谢大家
中高级裙：欢迎加入学习：493917955 （新群，现还没啥人哦）

废弃的root
关注
专栏目录
js实现Map
zyxwvutsrqponmlkjihg的专栏
06-19 879
/* * MAP对象，实现MAP功能 * * 接口： * size() 获取MAP元素个数 * isEmpty() 判断MAP是否为空 * clear() 删除MAP所有元素 * put(key, value) 向MAP中增加元素（key, value) * remove(key) 删除指定KEY的元素，成功返回True，失败返回F
HashMap、Hashtable、TreeMap、LinkedHashMap、IdentityHashMap、ConcurrentHashMap和WeakHashMap的区别
qq_36470686的博客
12-01 1406
一、Map概述 java为数据结构中的映射定义了一个接口java.util.Map;它有三个实现类,分别是HashMap、Hashtable 和TreeMap. Map是用来存储键值对的数据结构，在数组中通过数组下标来对其内容进行索引的，而在Map中，则是通过对象来进行索引，用来索引的对象叫做key，其对应的对象叫value。   二、类图   注：以下说的无序的意思是指不会记录插...
java集合14--Map总结
节至
05-08 893
概要学完了Map的全部内容，我们再回头开开Map的框架图。本章内容包括： 第1部分 Map概括 第2部分 HashMap和Hashtable异同 第3部分 HashMap和WeakHashMap异同转载请注明出处：http://www.cnblogs.com/skywang12345/admin/EditPosts.aspx?postid=3311126第1部分 Map概括(01) Map
HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)
JLegend的专栏
10-10 1912
第1部分 Map概括 Map 是“键值对”映射的抽象接口。 AbstractMap 实现了Map中的绝大部分函数接口。它减少了“Map的实现类”的重复编码。 SortedMap 有序的“键值对”映射接口。 NavigableMap 是继承于SortedMap的，支持导航函数的接口。 HashMap, Hashtable, TreeMap, WeakHashMap这4个类是“键值对”映射的
java new map
weixin_34186950的博客
01-23 833
  import com.google.common.collect.Maps;   public static Map&lt;String, Object&gt; configMap2 = new ConcurrentHashMap&lt;&gt;();public static Map&lt;String, Object&gt; configMap3 = Maps.newConcurrentM...
WeakHashMap的应用场景
互联网架构师笔记
04-24 968
WeakHashMap，从名字可以看出它是某种 Map。它的特殊之处在于 WeakHashMap 里的entry可能会被GC自动删除，即使程序员没有调用remove()或者clear()方法。
Java Map接口常用子类详解： HashMap, Hashtable, TreeMap & WeakHashMap
本篇PPT课程主要聚焦于Java编程中Map接口的常用子类，这些子类在实际开发中具有不同的特性和应用场景。Map接口在Java中是一种关联型容器，用于存储键值对，提供了高效的数据存储和查找功能。 首先，我们讨论的是...
Java集合类详解：ArrayList, Vector, HashMap与TreeMap
"Java中集合类用法总结" 在Java编程语言中，集合类是用于存储和管理对象的重要工具。本文将对Java集合框架中的主要类和接口进行详细阐述，以便于开发者更好地理解和运用。 首先，Java集合框架分为两大基本接口：`...
集合系列(五) -TreeMap详解
最新发布
程序员志哥的博客
03-18 1820
本文主要从数据结构和算法层面，探讨TreeMap的实现。
Java Map集合
yonggang7的专栏
02-07 3024
Map集合用于保存映射关系的数据，Map集合中保存了两组值，一组是 key， 一组是 value。 Map的key不能重复。 key和value之间存在单向一对一的关系， 通过key，能找到唯一的，确定的value。 HashMap和Hashtable是Map接口的实现类。 LinkedHashMap 是 HashMap的子类。 LinkedHashMap使用双向链表维护key-value的次序。使迭代顺序和插入顺序一致。
Java中的collection集合类型总结
09-02
`Map`接口的实现类包括`HashMap`（无序，快速访问）、`TreeMap`（有序，根据键的自然顺序或自定义比较器排序）、`WeakHashMap`（弱引用键，当键不再被引用时自动删除）以及古老的线程安全实现`Hashtable`。...
Java集合类中文介绍
09-04
Java集合类是Java编程语言中用于存储和管理对象的关键组件，位于`java.util`包下。集合类框架提供了一系列接口和实现，使开发者能够高效地处理数据。本文将深入介绍这个框架，特别是针对Collection、List、Set以及...
Java集合源码全面分析
09-02
Java集合框架是Java编程语言中不可或缺的一部分，它提供了一系列接口和类，用于高效地存储和操作数据。在本文中，我们将全面分析Java集合框架的核心概念和实现细节。 首先，Java集合框架的基础是`Collection`接口，...
Java 集合框架+集合实例
06-17
Java集合框架是Java编程语言中用于存储和管理对象的核心组件，它为开发者提供了灵活且高效的数据结构选择。这个框架的设计目标是确保高性能、高度互操作性以及易于扩展。以下是对标题和描述中涉及的知识点的详细说明...
Java中WeakHashMap的应用场景
初来乍到
07-15 3512
WeakHashMap是啥： WeakHashMap和HashMap都是通过"拉链法"实现的散列表。它们的源码绝大部分内容都一样，这里就只是对它们不同的部分就是说明。 WeakReference是“弱键”实现的哈希表。它这个“弱键”的目的就是：实现对“键值对”的动态回收。当“弱键”不再被使用到时，GC会回收它，WeakReference也会将“弱键”对应的键值对删除。 “弱键”是一个“弱引用(WeakReference)”，在Java中，WeakReference和ReferenceQueue 是..
WeakHashMap的使用
Discovery的专栏
12-04 1312
WeakHashMap的实现及其应用。
weakHashMap 用法
gmHappy
12-18 1710
WeakHashMap，此种Map的特点是： 当除了自身有对key的引用外，此key没有其他引用，那么GC之后此map会自动丢弃此值 举例来说：声明了两个Map对象，一个是HashMap，一个是WeakHashMap，同时向两个map中放入a、b两个对象，当HashMap remove掉a 并且将a、b都指向null时，WeakHashMap中的a将自动被回收掉。出现这个状况的原因是，对于a对象...
WeakHashMap源码解析及使用场景
李思苇
10-26 2010
目的 让Map中不再使用的Entry被GC及时回收，释放内存空间 用途 Map本身生命周期很长，需要长期贮留内存中，但Map中的Entry可以删除，使用时可以从其它地方再次取得。 实例：tomcat中的缓存有用到。 实现方式 对于WeakReference可以参考另一篇文章：弱引用——WeakReference——所引用的对象的回收规则 在WeakHashMap类中定义了一个实例域ReferenceQueue<Map.Entry> queue。 内部的Entry直接继承了WeakRefere
javascript实现java的map对象，js实现new map()
weixin_34153893的博客
07-26 159
 分类： javascript（84）  [html] view plain copy    print? /*    * MAP对象，实现MAP功能    *    * 接口：    * size()     获取MAP元素个数    * isEmpty()    判断MAP是否为空    * clear()     删除MAP所有元素    * put(key, valu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

废弃的root

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值