Java鸠合类Hashmap的细致引见（代码示例）【JAVA教程】,Java

本篇文章给人人带来的内容是关于Java鸠合类Hashmap的细致引见（代码示例），有肯定的参考价值，有须要的朋侪能够参考一下，愿望对你有所协助。

一.HashMap 简介

HashMap在程序员的开辟过程当中是一个非常经常使用的鸠合类,它是一个以键值对情势存在的鸠合类,

在开辟中我们能够运用的它的一个key存期近替代的特征,完成一个更新的去重的操纵。

在另一个轻易我们能够运用map跟fastJson疾速构成我们所需的json数据格式。

在jdk1.8之前,HashMap是以数组+链表的情势存在,put进来的key的hashCode进过扰动函数盘算后获得hash值,然后该值经由过程(n-1)&hash盘算后的到响应的位置(n代表的是数组长度),

假如发生了hash争执,则先推断该key是不是存在,假如存在那末就掩盖,否则以“拉链法”处理争执,便构成了链表。

但在jdk1.8以后,HashMap就发生了转变,假如当前链表的长度大于阈值（默许是8）那末该链表就转换成红黑树,加快了搜刮速率。

二.HashMap属性

//HashMap的默许初始容量 2^4=16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

//HashMap的最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;

//默许的装载因子当数组长度
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 当桶(bucket)上的结点数大于这个值时会转成红黑树
static final int TREEIFY_THRESHOLD = 8;

// 当桶(bucket)上的结点数小于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;

// 桶中构造转化为红黑树对应的table的最小大小
static final int MIN_TREEIFY_CAPACITY = 64;

// 存储元素的数组，老是2的幂次倍
transient Node<k,v>[] table;

// 寄存详细元素的集
transient Set<map.entry<k,v>> entrySet;

// 寄存元素的个数，注重这个不即是数组的长度。
transient int size;

// 每次扩容和变动map构造的计数器
transient int modCount;

// 临界值当现实大小(容量*添补因子)凌驾临界值时，会举行扩容（*当size大于即是threshold的时刻，并不肯定会触发扩容机制，然则会极可能就触发扩容机制，只需有一个新建的Entry涌现哈希争执，则马上resize）
int threshold;

// 添补因子当Size>=threshold的时刻，那末就要斟酌对数组的扩增了，也就是说，这个的意义就是权衡数组是不是须要扩增的一个规范
final float loadFactor;

三.HashMap的扩容机制

 public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

个中tableSizeFor这个代码是:

static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

>>>是一个疏忽标记位的位右挪动标记 |= 是摆布两个数举行&操纵

这个要领会把你传进来的初始化容量变成一个是2的平方次幂的数所以这里就牢固死了HashMap的容量必需是2的平方次幂

至于为何是2的平方次幂的数缘由以下：

1.put要领源码:

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

看到个中 p = tab[i = (n - 1) & hash]) == null 这一句 (n - 1) & hash是盘算到一个位置,假如这个tab中的位置是空的那末直接做插进去操纵。

举个列子假定有16个位置有4个门生都有各自的学号

称号	学号
张三	1
李四	2
王五	3
老李	4

此时我们分派位置的时刻能够采纳 1%16 = 1；2%16=2；3%16 = 3；4%16=4；给他们分派位置,然则斟酌到机能题目。因为%操纵比&慢10倍摆布，因而采纳&运算会进步机能。

经由过程限定length是一个2的幂数， (n - 1) & hash和hash%n结果是一致的。这就是为何要限定容量必需是一个2的幂的缘由。

比方2的hashCode是2 那末它对应的二进制是（0000 0010）

假定n=16

那末n-1=15对应的二进制是 1111 1111 & 0000 0010 = 1111 1111 = 0010 = 2

2%16=2

获得(n - 1) & hash和hash%n结果是一致的,斟酌到机能所以每次的扩容都是以2的幂次方扩容。

四.HashMap的简朴运用

public  static void mapMethod() {
		HashMap<String, Object> map = new HashMap<>();
		map.put("zhangsan", 11);
		map.put("lisi", 11);
		//反复key会掩盖
		map.put("zhangsan", 22);
		//方便
		for(String key:map.keySet()) {
			//依据key猎取value
			System.out.println(key+"=======value:"+map.get(key));
		}
		//containsKey要领推断当前map是不是包括该要领
		System.out.println(map.containsKey("zhangsan"));
		//size打印map的长度
		System.out.println(map.size());
		//移除key
		map.remove("zhangsan");
		//推断是不是存在value
		System.out.println(map.containsValue("22"));
	}