1、Map接口实现类的特点【很实用】
- 这里讲的是JDK8的Map接口特点 Map_.java
- Map 与 Collection 并列存在，用于保存具有映射关系的数据：Key-Value(双列元素)
- Map 中的 key 和 value 可以是任何引用类型的数据，会封装到HashMap$Node对象中
- Map 中的 key 不允许重复，原因和HashSet一样，前面分析过源码
- Map 中的 value 可以重复
- Map 中的key 可以为 null，value 也可以为null ， 注意 key 为null，只能有一个，value 为null ，一个多个
- 常用String类最为Map的key
- key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
- Map存放数据的key-value示意图，一对 k-v 是放在一个HashMap$Node中的，又因为Node 实现了 Entry 接口，有些书上也说一对 k-v 就是一个Entry
- Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。
2、Map接口常用方法
- put: 添加
- remove：根据键删除映射关系
- get：根据键获取值
- size：获取元素个数
- isEmpty：判断个数是否为0
- clear：清除
- containsKey：查找键是否存在
package com.hspedu.map_;
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings({"all"})
public class MapMethod {
public static void main(String[] args) {
Map map = new HashMap();
map.put("邓超",new Book("", 100));
map.put("邓超","孙俪");
map.put("王宝强","马蓉");
map.put("宋健","马蓉");
map.put("六零波",null);
map.put(null,"刘亦菲");
map.put("鹿晗","关晓彤");
System.out.println("map = " + map);
map.remove(null);
System.out.println("map = " + map);
Object val = map.get("鹿晗");
System.out.println("val = " + val);
System.out.println("k-v = " + map.size());
System.out.println(map.isEmpty());
map.clear();
System.out.println("map = " + map);
System.out.println(map.containsKey("hsp"));
}
}
class Book {
private String name;
private int num;
public Book(String name, int num) {
this.name = name;
this.num = num;
}
}
/*
运行结果：
map = {邓超=孙俪, null=刘亦菲, 宋健=马蓉, 王宝强=马蓉, 鹿晗=关晓彤, 六零波=null}
map = {邓超=孙俪, 宋健=马蓉, 王宝强=马蓉, 鹿晗=关晓彤, 六零波=null}
val = 关晓彤
k-v = 5
false
map = {}
false
*/
3、Map接口遍历方式
- containsKey：查找键是否存在
- keySet：获取所有的键
- entrySet：获取所有关系k-v
- values：获取所有的值
package com.hspedu.map_;
import java.util.*;
@SuppressWarnings({"all"})
public class MapFor {
public static void main(String[] args) {
Map map = new HashMap();
map.put("邓超","孙俪");
map.put("王宝强","马蓉");
map.put("宋健","马蓉");
map.put("六零波",null);
map.put(null,"刘亦菲");
map.put("鹿晗","关晓彤");
//第一组：先取出所有的Key ， 通过Key 取出对应的value
Set keyset = map.keySet();
//(1) 增强for
System.out.println("-------------第一种方式---------------");
for (Object key : keyset) {
System.out.println(key + "-" + map.get(key));
}
//(2) 迭代器
System.out.println("-------------第二种方式---------------");
Iterator iterator = keyset.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key + "-" + map.get(key));
}
//第二组：把所有的values 取出
Collection values = map.values();
//这里可以使用所有Collection使用的遍历方法
//(1) 增强for循环
System.out.println("---取出所有的value---");
for (Object value :values) {
System.out.println(value);
}
//(2) 迭代器
System.out.println("---取出所有的value 2 ---");
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()) {
Object value = iterator1.next();
System.out.println(value);
}
//第三组：通过EntrySet 来获取 k-v
Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
//(1) 增强for
System.out.println("---使用EntrySet ---");
for (Object entry : entrySet) {
//将entry 转成 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
//(2) 迭代器
Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()) {
Object entry = iterator2.next();
System.out.println(entry.getClass());//HashMap$Node - 实现-> Map.Entry (getKey, getValue)
//向下转型 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
}
}
/*
运行结果：
-------------第一种方式---------------
邓超-孙俪
null-刘亦菲
宋健-马蓉
王宝强-马蓉
鹿晗-关晓彤
六零波-null
-------------第二种方式---------------
邓超-孙俪
null-刘亦菲
宋健-马蓉
王宝强-马蓉
鹿晗-关晓彤
六零波-null
---取出所有的value---
孙俪
刘亦菲
马蓉
马蓉
关晓彤
null
---取出所有的value 2 ---
孙俪
刘亦菲
马蓉
马蓉
关晓彤
null
---使用EntrySet ---
邓超-孙俪
null-刘亦菲
宋健-马蓉
王宝强-马蓉
鹿晗-关晓彤
六零波-null
class java.util.HashMap$Node
邓超-孙俪
class java.util.HashMap$Node
null-刘亦菲
class java.util.HashMap$Node
宋健-马蓉
class java.util.HashMap$Node
王宝强-马蓉
class java.util.HashMap$Node
鹿晗-关晓彤
class java.util.HashMap$Node
六零波-null
*/
4、 Map接口实现类HashMap
1. 小结
- Map接口的常用实现类：HashMap、Hashtable和Properties。
- HashMap是Map接口使用频率最高的实现类
- HashMap是以 key-val 对的方式来存储数据（HashMap$Node类型）
- key不能重复，但是值可以重复，允许使用null健和null值
- 如果添加相同的key，则对覆盖原来的key-val，等同于修改（key不会替换，val会替换）
- 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的
- HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有synchronzied
2. HashMap底层机制及源码剖析
- (k,v)是一个Node 实现了Map.Entry<K,V>，查看HashMap 的源码可以看到
- jdk7.0的hashmap 底层实现了[数组+链表]，jdk8.0的hashmap 底层实现了[数组+链表+红黑树]
-
扩容机制 [和HashSet相同]
- HashMap底层维护了Node类型的数组table，默认为null
- 当创建对象时，将加载因子（loadfactor）初始化为0.75
- 当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key和准备加入的key是否相等，如果相等，则直接替换val；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容
- 第1次添加，则需要扩容tale容量为16，临界值（threshold）为12（16 * 0.75）
- 以后再扩容，则需要扩容table容量为原来的2倍（32），临界值为原来的2倍，即24，依此类推
- 再java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD (默认是8) ，并且table的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树）
package com.hspedu.map_; import java.util.HashMap; @SuppressWarnings({"all"}) public class HashMapSource1 { public static void main(String[] args) { HashMap map = new HashMap(); map.put("java",10); map.put("php",10); map.put("java",20); System.out.println("map = " + map); /* 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<K,V>[] tab; Node<K,V> 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<K,V> 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<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); //加入后，判断当前链表的个数，是否已经到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; afterNodeAccess(e); return oldValue; } } ++modCount; //每增加一个Node，就size++ if (++size > threshold) // 如果size > 临界值，就扩容 resize(); afterNodeInsertion(evict); return null; } 4. 关于树化(转成红黑树) //如果table 为null ，或者大小还没有到64，暂时不树化，而是进行扩容 //否则才会真正的树化 -> 剪枝 final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); } */ } } /* 运行结果： map = {java=20, php=10} */ -
模拟HashMap触发扩容、树化情况，并Debug验证
5、 Map接口实现类HashTable
1. HashTable的基本介绍
-
存放的元素是键值对：即k-v
-
hashTable 的键和值都不能为null
-
hashTable 使用方法基本上和HashMap一样
-
hashTable 是线程安全的，hashMap 是线程不安全的
-
底层结构分析
package com.hspedu.map_; import java.util.Hashtable; @SuppressWarnings({"all"}) public class HashTableExercise { public static void main(String[] args) { Hashtable table = new Hashtable(); table.put("john",100); //table.put(null,100); //table.put("john",null); table.put("lucy",100); table.put("lic",100); table.put("lic",80); 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); //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.Hashtable 和 HashMap对比
| 版本 | 线程安全（同步） | 效率 | 允许null键null值 | |
|---|---|---|---|---|
| HashMap | 1.2 | 不安全 | 高 | 可以 |
| Hashtable | 1.0 | 安全 | 较低 | 不可以 |
6、 Map接口实现类Properties
- Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据
- 他的使用特点和Hashtable类似
- Properties 还可以用于 从 xxx.properties 文件中，加载数据到Properties类对象，并进行读取和修改
package com.hspedu.map_;
import java.util.Hashtable;
import java.util.Properties;
@SuppressWarnings({"all"})
public class Properties_ {
public static void main(String[] args) {
Properties properties = new Properties();
properties.put("john",100);
//properties.put(null,"abc"); //抛出 空指针异常
//properties.put("abc",null); //抛出 空指针异常
properties.put("lucy",100);
properties.put("lic",100);
properties.put("lic",88);
System.out.println("properties = " + properties);
//通过k 获取对应值
System.out.println(properties.get("lic"));
//删除
properties.remove("lic");
System.out.println("properties = " + properties);
//修改
properties.put("john","约翰");
System.out.println("properties = " + properties);
}
}
/*
允许结果：
properties = {john=100, lic=88, lucy=100}
88
properties = {john=100, lucy=100}
properties = {john=约翰, lucy=100}
*/
7、TreeMap
- 和treeSet类似