1. HashMap 小结 535
1) Map接口的常用实现类HashMap、 Hashtable和Properties.
2) HashMap是Map接口使用频率最高的实现类。
3) HashMap是以key-val对的方式来存储数据(HashMap$Node类型)
4) key不能重复，但是值可以重复，允许使用null键和null值。
5)如果添加相同的key，则会覆盖原来的key-val ,等同于修改.(key不会替换，val会替换)
6)与HashSet-样，不保证映射的顺序，因为底层是以hash表的方式来存储的. jdk8的
hashMap底层数组+链表+红黑树)
7) HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有
synchronized
2. HashMap 底层机制及源码剖析 536
1) (k,v) 是一个Node实现了Map.Entry，查看HashMap的源码可以看到.
2) jdk7 .0的hashmap底层实现[数组+链表]，jdk8.0底层[数组+链表+红黑树]
3. HashMap 底层机制及源码剖析 536-537
➢扩容机制[和HashSet相同]
1) HashMap底层维护了Node类型的数组table,默认为null
2)当创建对象时，将加载因子(loadfactor)初始化为0.75.
3)当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key和准备加入的key相是否等，如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
4)第1次添加，则需要扩容table容量为16,临界值(threshold)为12 (16*0.75)
5)以后再扩容，则需要扩容table容量为原来的2倍(32),临界值为原来的2倍，即24依次类推
6)在Java8中，如果条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且table的大小>= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树)
代码在com.stulzl.hashmap_source01.包中 537
HashMap_Source01
package com.stulzl.hashmap_source01;
import java.util.HashMap;
//HashMap 底层机制及源码剖析 537
@SuppressWarnings({"all"})
public class HashMap_Source01 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("java", 10);//ok
map.put("php", 10);//ok
map.put("java", 20);//替换value
System.out.println("map=" + map);//map={java=20, php=10}
/*解读HashMap的源码+图解
1. 执行构造器 new HashMap()
初始化加载因子 loadfactor = 0.75
HashMap$Node[] table = null
2. 执行put 调用 hash方法，计算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {//K = "java" value = 10
return putVal(hash(key), key, value, false, true);
}
3. 执行 putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;//辅助变量
//如果底层的table 数组为null, 或者 length =0 , 就扩容到16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//取出hash值对应的table的索引位置的Node, 如果为null, 就直接把加入的k-v
//, 创建成一个 Node ,加入该位置即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node e; K k;//辅助变量
// 如果table的索引位置的key的hash相同和新的key的hash值相同，
// 并 满足(table现有的结点的key和准备添加的key是同一个对象 || equals返回真)
// 就认为不能加入新的k-v
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理
e = ((TreeNode)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);
//加入后，判断当前链表的个数，是否已经到8个，到8个，后
//就调用 treeifyBin 方法进行红黑树的转换
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && //如果在循环比较过程中，发现有相同,就break,就只是替换value
((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; //替换，key对应value
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//每增加一个Node ,就size++
if (++size > threshold[12-24-48])//如size > 临界值，就扩容
resize();
afterNodeInsertion(evict);
return null;
}
5. 关于树化(转成红黑树)
//如果table 为null ,或者大小还没有到 64，暂时不树化，而是进行扩容.
//否则才会真正的树化 -> 剪枝
final void treeifyBin(Node[] tab, int hash) {
int n, index; Node e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
}
*/
}
}4. 模拟HashMap触发扩容、树化情况，并Debug验证.538
代码在com.stulzl.hashmap_source02.包中
HashMap_Source02
package com.stulzl.hashmap_source02;
import java.util.HashMap;
import java.util.Objects;
// 模拟HashMap触发扩容、树化情况，并Debug验证.538
@SuppressWarnings({"all"})
public class HashMap_Source02 {
public static void main(String[] args) {
HashMap hashMap = new HashMap();
for (int i = 1; i <=12; i++) {
hashMap.put(new A(i),"hello");
}
//12 个k-v,因为重写了hash值方法，所以hash值一样，所有的数据都挂载到一个链表上
System.out.println("hashMap="+hashMap);
}
}
class A{
private int num;
public A(int num) {
this.num = num;
}
@Override
public String toString() {
return "\nA{" +
"num=" + num +
'}';
}
//重写hash值 使所有的A对象的hashCode都是100
@Override
public int hashCode() {
return 100;
}
}5. HashTable 的基本介绍
1)存放的元素是键值对:即K-V
2) hashtable的键和值都不能为null, 否则会抛出NullPointerException
3) hashTable使用方法基本上和HashMap一样
4) hashTable是线程安全的(synchronized), hashMap是线程不安全的
5.1 HashTable的基本介绍应用案例 539-540
代码在com.stulzl.hashtable.包中
Hashtable_Exercise01
package com.stulzl.hashtable;
import java.util.Hashtable;
//HashTable的基本介绍应用案例 539-540
@SuppressWarnings({"all"})
public class Hashtable_Exercise01 {
public static void main(String[] args) {
Hashtable table = new Hashtable();
table.put("john", 100); //ok
//hashtable的键和值都不能为null, 否则会抛出NullPointerException
//table.put(null, 100); //异常 NullPointerException
//table.put("john", null);//异常 NullPointerException
table.put("lucy", 100);//ok
table.put("lic", 100);//ok
table.put("lic", 88);//替换
table.put("hello1", 1);
table.put("hello2", 1);
table.put("hello3", 1);
table.put("hello4", 1);
table.put("hello5", 1);
table.put("hello6", 1);
System.out.println(table);
//简单说明一下Hashtable的底层
//1. 底层有数组 Hashtable$Entry[] 初始化大小为 11
//2. 临界值 threshold 8 = 11 * 0.75
//3. 扩容: 按照自己的扩容机制来进行即可.
//4. 执行 方法 addEntry(hash, key, value, index); 添加K-V 封装到Entry
//5. 当 if (count >= threshold) 满足时，就进行扩容
//6. 按照 int newCapacity = (oldCapacity << 1) + 1; 即(*2+1)的大小扩容.
}
}6. Hashtable 和 HashMap 对比 540
7. Map 接口实现类-Properties 541
7.1 基本介绍
1. Properties类继承自Hashtable类并且实现了 Map接口，也是使用一种键值对的形式来保存数据。
2.他的使用特点和Hashtable类似
3. Properties 还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改
4.说明:工作后xxx.properties 文件通常作为配置文件，这个知识点在IO流举例，有兴趣可先看文章
7.2 Properties基本使用案例 541
代码在com.stulzl.properties.包中
Properties_
package com.stulzl.properties;
import java.util.Properties;
//Properties基本使用案例 541
@SuppressWarnings({"all"})
public class Properties_ {
public static void main(String[] args) {
//解读
//1. Properties 继承 Hashtable
//2. 可以通过 k-v 存放数据，当然key 和 value 不能为 null
//增加
Properties properties = new Properties();
//properties.put(null, "abc");//抛出 空指针异常
//properties.put("abc", null); //抛出 空指针异常
properties.put("john", 100);//k-v
properties.put("lucy", 100);
properties.put("lucy", 200);
properties.put("lic", 100);
properties.put("lic", 88);//如果有相同的key ， value被替换
System.out.println("properties="+properties);
//通过k 获取对应值
System.out.println(properties.get("lic"));//88
//删除
//properties.remove("lic");
System.out.println("properties="+properties);
//修改
properties.put("john","约翰");
System.out.println("properties="+properties);
//查
System.out.println(properties.get("lic"));//88
System.out.println(properties.getProperty("lucy"));//如果value部位String类型返回null
}
}8. 总结-开发中如何选择集合实现类(记住) 542
在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行
选择，分析如下:
1)先判断存储的类型(一组对象[单列]或组键值对[双列)
2)一组对象[单列]: Collection接口
允许重复: List
增删多: LinkedList [底层维护了一个双向链表]
改查多: ArrayList [底层维护Object类型的可变数组]
不允许重复: Set
无序HashSet [底层是HashMap，维护了一一个哈希表即(数组+链表+红黑树)]
排序: TreeSet
插入和取出顺序一致: LinkedHashSet ， 维护数组+双向链表
3)一组健值对[双列]: Map
键无序: HashMap [底层是:哈希表jdk7: 数组+链表，jdk8: 数组+链表+红黑树]
键排序: TreeMap
键插入和取出顺序一致: LinkedHashMap
读取文件Properties
