目录
hashMap是基于Hash表的Map实现,存储的方式未key:value类型的键值对,同时允许key、value为null,如果出现像如同的key或者value十,新值将会覆盖之前的值。
使用
//初始化HashMap
Map<String,Object> hashMap = new HashMap<String, Object>();
//赋值
hashMap.put("id",1);
hashMap.put("name","张三");
//取值
Integer id = (Integer) hashMap.get("id");
String name = (String) hashMap.get("name");
System.out.println("id:"+id);
System.out.println("name:"+name);
这就是一个简单的马匹使用,其中Map<String,Object> 你可以制定map的键值对类型,也可以不指定直接,如:
Map hashMap = new HashMap<();
这样写代表此map的键值对都是object类型的,你可以随访存放你的类型,如果你只想存储String类型的key,int类型的value,声明如下:
Map<String,Integer> hashMap = new HashMap<String, Integer>();
在这里需要注意一点,制定类型的时候只能十包装类型,也就是 Long、Integer、Double等等,是不能使用long、int、double。
这里还有一个问题,那就是如果我不知道我存的key是什么我能拿到HashMap的数据吗?当然可以
//初始化HashMap
Map<String,Object> hashMap = new HashMap<String, Object>();
//赋值
hashMap.put("id",1);
hashMap.put("name","张三");
//取值
// Integer id = (Integer) hashMap.get("id");
// String name = (String) hashMap.get("name");
//获取所有的key值
Set<String> keys=hashMap.keySet();//将map的key转换成set集合
Iterator<String> keyInterator1=keys.iterator();//将keys转换成迭代器
System.out.println("map的所有key值===============");
while (keyInterator1.hasNext()){
System.out.println(keyInterator1.next() );
}
System.out.println("map的所有value值===============");
Collection<Object> values=hashMap.values();
Iterator<Object> keyInterator2=values.iterator();
while (keyInterator2.hasNext()){
System.out.println(keyInterator2.next());
}
请看结果:
是不是与上面的赋值对应上了
下面来介绍一下HashMap的性能以及安全问题
刚刚说了HashMap的存储是基于hash算法实现的,那他具体是如何实现的呢?当程序执行HashMap的put方法时,将调用String的 hashCode() 方法得到其 hashCode 值,在这里说明一下HashCode的因子是31,最后会根据计算出来的HashCode存放Map的元素.
扩容机制
我们先来看一下HashMap的初始化,HashMap提供了4中构造函数:
//无参构造
Map<String,Object> map1 = new HashMap<String, Object>();
//有参构造 传入初始容器大小
Map<String,Object> map2 = new HashMap<String, Object>(100);
//有参构造 传入初始容器以及负载因子
Map<String,Object> map3 = new HashMap<String, Object>(100,0.8f);
//有参构造 讲一个map赋值给一个新的map
Map<String,Object> map4 = new HashMap<String, Object>(map1);
我们现在分别来看一下这几个构造函数的源码:
1.new HashMap()
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
此构造只做了一件事,那就是给负载因子赋初始值:0.75
2.new HashMap<String, Object>(100);
initialCapacity:初始化的容器大小
DEFAULT_LOAD_FACTOR:初始化的负载因子大小:0.75
threshold:容器的初始化大小
但是需要注意一点我们给的初始化容器大小:100并不是最终的大小,请看下面代码:
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的幂形式,所以并不是我们实例化指定的,它是通过你给定的大小计算出最终的大小。
第三种和第二种构造一样,唯一区别就是第三种可以手动指定负载因子,而第二种只能使用默认的负载因子,第四种事拷贝map到新的map中。
新增方法(put)
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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;
}
当第一次调用put()时,会进行一次resize(),resize主要作用:
1.扩容。
2.分配容器大小。
3.分配扩容的阈值。
4.如果发生扩容,数据拷贝。
源码如下:
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
我们使用第一个构造函数进行debug调式:
oldThr = threshold:容器的初始化大小,由于我们没有指定,所以这里等于0
请看,重点来了,请看下面这两行代码:
newCap:容器默认的大小:16
newThr:扩容的大小:容器大小 * 负载因子 = 16* 0.75 = 12
但是这里需要注意一点,newCap不会作为最终的容器大小,往下看你会发现程序将newThr(12)赋值给了threshold,也就是说容器的大小变成了12,而不是之前的默认大小16,这点需要特别注意,其实之前说的threshold(容器大小)不是真正的容器大小,而是需要进行扩容的阈值,那容器的大小是由哪个字段决定的呢?请看代码:
容器的大小会被保留在table这个字段中,那一次扩容的大小是多少呢?我们来看下面这段代码:
看到没有,扩容的时候会执行oldThr << 1:oldThr 左移1位,也就是上一次的扩容阈值*2 = 12*2=24,所以下次容器中要塞满24条数据才能再次出发扩容。
关于有参构造的扩容方式也是类似,只是在初始化resize的时候会使用给定的值(通过特定的算法得出的容器大小,上面已经讲过了,并不是你传入的大小,这点一定要特别注意)*负载因子而不是默认的值,感兴趣的朋友可以自己跟着源码走一遍,不难理解
总结
容器扩容是由容器大小以及负载因子共同决定的,同时容器大小和负载因子都是可以在初始化的时候指定,那是不是可以将负载因子设置为1呢?让数据达到容器的最大值在进行扩容,如果一定要这样设计也是可以的,但是不推荐,设置的太高,可能会发生Hash碰撞问题,所以官方给出的0.75是一个比较合理的数值。
那我们实例化的时候HashMap的时候是否需要给定初始化容器大小呢?这个就要看具体需求了,如果map中存储的数据不多,仅仅只是几个查询条件,那么大可不必设置初始大小,默认的已经够了,另外一种,我们需要用map接收几万的数据,这个时候就需要我们设置一下容器的初始化大小,为什么呢?,与如果不设置,那么map在数据达到12的时候会进行一次扩容,数据达到24的时候进行一次扩容。。。。。。。几万的数据,会扩容很多次,但是孔融还有一点刚刚我没有降到,那就是扩容时会伴随着数据拷贝,扩容次数越多,拷贝的次数也就越多,这样会浪费性能,所以到底如何选择容器的大小,我们应该结合实际情况做出不同的方法。