文章介绍了Map接口的特点，包括Key-Value的映射关系，Key的唯一性以及Value的可重复性。通过示例展示了HashMap的使用，包括添加、删除、获取元素以及扩容机制。还提到了Hashtable作为线程安全的Map实现，不允许null键值，并且详细阐述了Properties类在存储配置信息时的作用。
文章目录
Map为双列集合，Set集合的底层也是Map，只不过有一列是常量所占，只使用到了一列。
01 Map 接口实现类的特点
- Map 与 Collection 并列存在，用于保存具有映射关系的数据：Key - Value；
- Map 中的 Key 和 Value 可以是任何引用类型的数据，会封装到 HashMap$Node对象中；
- Map中的 Key 不允许重复，原因和 HashSet 一样;
- Map 中的 Value 可以重复；
- Map 的 Key 可以为 null，value 也可以为 null，但 key 为 null 只能有一个；
- 常用 String 类作为 Map 的 key，当然，其他类型也可以，但不常用；
- Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到对应的 Value；
import java.util.HashMap;
import java.util.Map;
public class Map_ {
//分析Map接口实现类的特点
public static void main(String[] args){
//1. Map 与 Collection 并列存在，用于保存具有映射关系的数据：Key - Value；
Map map = new HashMap();
map.put("No.1","我");//Key-Value
map.put("No.2","你");// K-V
map.put("No.3","他");// K-V
System.out.println(map);//{No.2=你, No.1=我, No.3=他}
//2. Map 中的 Key 和 Value 可以是任何引用类型的数据，会封装到 HashMap$Node对象中
//3. Map中的 Key 不允许重复，原因和HashSet一样
//4.Map 中的 Value 可以重复
map.put("No.2","X"); //替换机制
map.put("No.4","他");
System.out.println(map);//{No.2=X, No.1=我, No.4=他, No.3=他}
//5. Map 的 Key 可以为 null，value 也可以为 null，但 key 为 null 只能有一个；
map.put("null","1");
map.put("null","2");
map.put("No.2","null");
map.put("No.3","null");
System.out.println(map);//{No.2=null, No.1=我, No.4=他, No.3=null, null=2}
//6. 常用 String 类作为 Map 的 key，当然，其他类型也可以，但不常用；
//7. Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到对应的 Value；
//通过get方法，传入key，会返回对应的value
System.out.println(map.get("No.1"));//我
}
}
- Map 存放数据的 key - value 示意图，一对 k - v 是放在一个 HashMap$Node 中的，又因为 Node 实现了 Entry 接口，所以也可以说，一对 k - v 就是一个 Entry ；
02 Map 接口和常用方法
- put ：添加
- remove ： 根据键删除映射关系
- get ： 根据键获取值
- size ： 获取元素个数
- isEmpty ： 判断个数是否为0
- clear ： 清除
- containsKey ： 查找键是否存在
import java.util.HashMap;
import java.util.Map;
//演示 Map 接口常用方法
public class MapMethod {
public static void main(String[] args) {
Map map = new HashMap();
//put方法：添加元素
map.put("海绵宝宝","章鱼哥");
map.put("海绵宝宝","派大星");
map.put("熊大","熊二");
map.put("大头儿子","小头爸爸");
map.put("黑猫警长",null);
map.put(null,"奥特曼");
System.out.println(map);//{黑猫警长=null, null=奥特曼, 大头儿子=小头爸爸, 熊大=熊二, 海绵宝宝=派大星}
//remove方法：根据键删除映射关系
map.remove(null);
System.out.println(map);//{黑猫警长=null, 大头儿子=小头爸爸, 熊大=熊二, 海绵宝宝=派大星}
//get方法：根据键获取
System.out.println(map.get("海绵宝宝"));//派大星
//size方法：获取元素个数
System.out.println(map.size());//4
//isEmpty方法：判断个数是否为0
System.out.println(map.isEmpty());//false
//containsKey方法：查找键是否存在
System.out.println(map.containsKey("黑猫警长"));//true
//clear方法：清空
map.clear();
System.out.println(map);//{}
}
}
03 Map 接口遍历方法
- containsKey ： 查找键是否存在
- keySet ： 获取所有的键
- entrySet ：获取所有关系
- values ： 获取所有的值
import java.util.*;
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,"奥特曼");
//第一种：先取出所有的Key，通过Key取出对应的value
Set keySet = map.keySet();
//(1)增强for
for(Object key : keySet){
System.out.println(key+" - "+map.get(key));
}
//(2)迭代器
Iterator iterator = keySet.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key+" - "+map.get(key));
}
//第二种：把所有的value取出
Collection values = map.values();
//然后遍历Collection就行
//(1)增强for
for(Object value : values){
System.out.println(value);
}
//(2)迭代器
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()) {
Object value = iterator1.next();
System.out.println(value);
}
//第三种：通过EntrySet来获取
Set entrySet = map.entrySet();
//(1)增强for
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 next = iterator2.next();
//向下转型 Map.Entry
Map.Entry m = (Map.Entry) next;
System.out.println(m.getKey()+" - "+m.getValue());
}
}
}
04 HashMap 用例 小结
使用 HashMap 添加3个员工对象，要求：
键：员工id
值：员工对象
并遍历显示工资 > 18000的员工
（员工类：姓名，工资，员工id）
import java.util.*;
public class MapExercise {
public static void main(String[] args) {
//创建、添加
HashMap hashMap = new HashMap();
hashMap.put(1,new Emp("Jack",30000,1));
hashMap.put(2,new Emp("Tom",20000,2));
hashMap.put(3,new Emp("Milan",12000,3));
//遍历一：使用keySet -> 增强for
Set keySet = hashMap.keySet();
for(Object key : keySet){
//先获取value
Emp emp = (Emp) hashMap.get(key);
//薪水大于18000就打印
if(emp.getSal() > 18000){
System.out.println(emp);
}
}
//遍历二：使用EntrySet -> 迭代器
Set entrySet = hashMap.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry)iterator.next();
//通过entry取得key和value
Emp emp = (Emp) entry.getValue();
if(emp.getSal() > 18000){
System.out.println(emp);
}
}
}
}
class Emp{
private String name;
private double sal;
private int id;
public Emp(String name, double sal, int id) {
this.name = name;
this.sal = sal;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Emp{" +
"name='" + name + '\'' +
", sal=" + sal +
", id=" + id +
'}';
}
}
- Map 接口的常用实现类：HashMap、Hashtable、Properties;
- HashMap 是 Map 接口使用频率最高的实现类；
- HashMap 是以 key - value 对的形式来存储的；
- key 不能重复添加，但value可以，都允许使用null；
- 如果添加相同的 key，则会覆盖原来的 key - value，等同于修改；
- 与 HashSet一样，不保证映射的顺序，因为底层是以hashbiao的方式来存储的；
- HashMap 没有实现同步，所以线程不安全；
05 HashMap 底层&扩容机制
- HashMap 底层维护了 Node 类型的数组 table ，默认为 null；
- 当创建对象时，将加载因子（loadfactor）初始化为0.75；
- 当添加 key-value 时，通过 key 的哈希值得到在 table的索引，然后判断该索引处是否有元素，如果没有元素则直接添加。如果该索引处有元素，继续判断该元素的 key 是否和准备加入的 key 相等，如果相等，则直接替换 value；如果不相等，则需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。（扩容机制和HashSet完全一样，因为HashSet底层就是HashMap）
- 第一次添加，会扩容 table 容量为16，临界值（threshold）为12；
- 以后再扩容，会扩容 table 容量为原来的2倍，临界值为原来的2倍，即24，以此类推；
- 在Java8中，如果一条链表的元素个数超过 TREEIFY_THRESHOLD（默认是8），并且 table的大小>= MIN_CAPACITY（默认是64），就会进行树化（红黑树）；
06 Hashtable
Hashtable的基本介绍：
- 存放的元素都是键值对，即 key - value；
- Hashtable 的键和值都不能为 null，否则会抛出NullPointerException
- Hashtable 使用方法基本上和 HashMap 一样；
- Hashtable 是线程安全的（synchronized）， HashMap是线程不安全的；
Hashtabel table = new Hashtable();
table.put("John",100);//OK
table.put(null,100);//异常 NullPointerException
table.put("",null);//异常
table.put("John",128);//替换
Hashtable的底层原理：
1.底层有数组 Hashtables$Entry[] 初始化大小为1；
2.临界值 threshold 8 = 11 * 0.75；
3.扩容机制：执行方法 addEntry(hash,key,value,index);添加 K-V，封装到Entry；
4.当 if(count >= threshold) 满足就扩容；
5.按照 int newCapacity = (oldCapacity << 1)+1; 扩容
| 对比 | 线程安全（同步） | 效率 | 允许 null 键 null 值 |
|---|---|---|---|
| HashMap | 不安全 | 高 | 可以 |
| Hashtable | 安全 | 较低 | 不可以 |
07 TreeMap
TreeMap 构造器可以传入比较器，所以TreeMap常用来排序，可以自定义存放数据顺序。
import java.util.Comparator;
import java.util.TreeMap;
public class TreeMap_ {
public static void main(String[] args) {
TreeMap treeMap = new TreeMap();//默认构造器，默认比较：自然排序
treeMap.put("Jack","杰克");
treeMap.put("Tom","汤姆");
treeMap.put("Smith","史密斯");
System.out.println(treeMap);//{Jack=杰克, Smith=史密斯, Tom=汤姆}由小到大排序
//如果按照传入的key由大到小排序：
treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o2).compareTo((String)o1);
//如果是按照长度由大到小：return ((String)o1).length()-((String)o2).length();
}
});
treeMap.put("Jack","杰克");
treeMap.put("Tom","汤姆");
treeMap.put("Smith","史密斯");
System.out.println(treeMap);//{Tom=汤姆, Smith=史密斯, Jack=杰克} 由大到小排序
}
}
08 Properties
- Properties 类继承自 Hashtable 类并且实现了Map接口，也是使用一种键值对的形式来保存数据；
- 使用特点和 Hashtable 相似；
- Properties 还可以用于从 xxx.properties 文件中，加载数据到Properties类对象，并进行读取和修改；
- 说明：xxx.properties 文件通常作为配置文件，这在 IO流 也有讲解
扫一扫
3486
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
