目录
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的时候进行一次扩容。。。。。。。几万的数据，会扩容很多次，但是孔融还有一点刚刚我没有降到，那就是扩容时会伴随着数据拷贝，扩容次数越多，拷贝的次数也就越多，这样会浪费性能，所以到底如何选择容器的大小，我们应该结合实际情况做出不同的方法。
