简述及特点

Map(映射)是双列集合，用于存储键值对的集合。

  • 键（Key）：用于查找值的唯一标识。一个Map不能包含重复的键。
  • 值（Value）：通过键相关联的数据。值可以重复，一个值可以被映射到多个键上。特点：
  1. 键的唯一性：每个键最多只能映射到相同的值。
  2. 值得可重复性：不同的键可以映射到相同的值。
  3. 键和值都可以为：null（具体取决于实现类，如HashMap允许，而Hashtable不允许）
  4. 不保证顺序：大多数实现不保证元素的储存顺序，但也有保证顺序的实现。

常用方法

方法 作用 返回值
put(K key,V value) 添加元素 V
remove(Object key) 根据键删除键值对元素 V
clear() 移除所有的键值对元素 void
containsKey(Object key) 判断集合是否包含指定的键 boolean
containsValue(Object value) 判断集合是否包含指定的值 boolean
isEmpty() 判断结合是否为空 boolean
size() 集合的长度，也就是集合中键值对的个数 int

代码示例：

1.创建Map集合的对象 

1
Map<String,String> m = new HashMap<>();

2.添加元素
put方法的细节：
添加/覆盖
在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中，方法返回null
在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回

1
2
3
4
5
6
7
8
m.put("A","a");  
String value1 = m.put("B","b");  
m.put("C","c");  
m.put("D","d");  
  
String value2 = m.put("B","b");  
System.out.println(value1);  
System.out.println(value2);

删除

1
2
String result = m.remove("C");  
System.out.println(result);

清空

1
m.clear();

判断是否包含

1
2
3
4
5
boolean keyResult = m.containsKey("D");  
System.out.println(keyResult);  
  
boolean valueResult = m.containsValue("d");  
System.out.println(valueResult);

判断是否为空

1
2
3
4
5
boolean result2 = m.isEmpty();  
System.out.println(result2);  
  
int size = m.size();  
System.out.println(size);

Map的三种遍历方式

前提：

1
2
3
4
5
6
7
8
9
//1.创建Map集合的对象  
Map<String,String> map = new HashMap<>();  
  
//2.添加元素  
map.put("A","a");  
map.put("B","b");  
map.put("C","c");  
map.put("D","d");  
map.put("E","e");

方法一：

通过键找值 

1
2
3
4
5
6
//3.1获取所有的键，把这些键放到一个单间集合当中  
Set<String> keys = map.keySet();  
//3.2遍历单列集合，得到每一个键  
for(String key : keys){  
    //3.3利用map集合中的键获取对应的值 get    String value = map.get(key);  
    System.out.println(key+"="+value);

方法二：

通过键值对对象进行遍历 

1
2
3
4
5
6
7
8
//3.1通过一个方法获取所有的键值对对象，返回一个Set集合  
Set<Map.Entry<String,String>> entries = map.entrySet();  
//3.2遍历entries这个集合，去得到里面的每一个键值对对象  
for(Map.Entry<String,String> entry : entries){  
    //3.3利用entry调用get方法获取键和值  
    String key = entry.getKey();  
    String value = entry.getValue();  
    System.out.println(key + "=" + value);

方法三：

利用lambda表达式进行遍历 

1
2
3
4
5
6
7
8
9
10
11
12
//底层:
//forEach其实就是利用第二种方式进行遍历，依次得到每一个键和值  
//再调用accept方法  
map.forEach(new BiConsumer<String, String>() {  
    @Override  
    public void accept(String s, String s2) {  
        System.out.println(s + "=" + s2);  
    }  
});  
  
//利用lambda表达式简化  
map.forEach((key,value)-> System.out.println(key+"="+value));