【集合系列】Map 双列集合

实现类：

• HashTable、HashMap、TreeMap、Properties、LinkedHashMap

其他集合类

具体信息请查看 API 帮助文档

1. 概述

Map是Java中的一种数据结构，用于存储键值对（key-value pair）。它是一个接口，实现了将键映射到值的功能。Map接口是一个泛型接口，可以指定键和值的类型。

Map集合的特点：

1. 键的唯一性：Map中的键是唯一的，每个键最多只能映射到一个值。如果尝试使用相同的键添加新的值，将会替换之前的值。

2. 无序性：一般情况下，Map的实现类（如HashMap，LinkedHashMap）不保证键值对的顺序。如果需要按特定顺序进行遍历，可以选择使用TreeMap等有序实现类。

3. 可以包含null键和null值：Map接口允许使用null作为键和值。但是需要注意，在使用含有null键的Map时，对键的查找和比较可能会出现NullPointerException异常。

4. 查找效率高：根据键的哈希值可以快速查找到对应的值，因此查找的效率很高。对于HashMap等实现类，查找时间复杂度一般为O(1)。

5. 动态调整大小：Map接口的实现类可以根据需要动态调整容量，默认情况下，它们会自动进行扩容和收缩。

Map集合是一个接口，不能直接创建对象，而是要创建实现类对象

2. 方法

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

注意事项：

1. V put(K key,V value) ：添加元素

   • put方法的细节：添加/覆盖

     • 在添加元素的时候，如果键不存在，那么直接添加键值对对象到map集合中，返回值返回null；

     • 在添加元素的时候，如果键存在，那么会把原有的键值对对象覆盖，返回被覆盖的键值对对象的值

2. V remove(Object key) ：根据键删除键值对元素

   • remove方法的细节：返回值返回的是被删除的键值对对象的值

3. 代码示例

package text.text02;

import java.util.HashMap;
import java.util.Map;

/*
Map集合：（Map集合是一个接口，不能直接创建对象，而是要创建实现类对象）

1.Map集合概述
  interface Map<K,V>  K：键的类型；V：值的类型
2.Map集合的特点
  - 双列集合,一个键对应一个值
  - 键不可以重复,值可以重复
3.方法介绍：
  | 方法名                              | 说明                                 |
  | ----------------------------------- | ------------------------------------ |
  | V   put(K key,V   value)            | 添加元素                             |
  | V   remove(Object key)              | 根据键删除键值对元素                 |
  | void   clear()                      | 移除所有的键值对元素                 |
  | boolean containsKey(Object key)     | 判断集合是否包含指定的键             |
  | boolean containsValue(Object value) | 判断集合是否包含指定的值             |
  | boolean isEmpty()                   | 判断集合是否为空                     |
  | int size()                          | 集合的长度，也就是集合中键值对的个数 |
注意事项：
    1.V   put(K key,V   value) ：添加元素
    put方法的细节：添加/覆盖
       在添加元素的时候，如果键不存在，那么直接添加键值对对象到map集合中，返回值返回null；
       在添加元素的时候，如果键存在，那么会把原有的键值对对象覆盖，返回被覆盖的键值对对象的值

    2. V   remove(Object key) ：根据键删除键值对元素
     remove方法的细节：返回值返回的是被删除的键值对对象的值
 */
public class text45 {
    public static void main(String[] args) {
        //创建集合对象(Map集合是一个接口，不能直接创建对象，而是要创建实现类对象)
        Map<String, String> map = new HashMap<>();


        System.out.println("========================== 添加元素  ==========================");
        //1.添加元素
        map.put("刘备", "孙尚香");
        map.put("李白", "王昭君");
        map.put("孙策", "小乔");
        map.put("周瑜", "小乔");
        map.put("孙悟空", "露娜");
        map.put("亚瑟", "安琪拉");
        System.out.println("添加元素的集合：" + map);  //{李白=王昭君, 刘备=孙尚香, 孙策=小乔, 孙悟空=露娜, 亚瑟=安琪拉, 周瑜=小乔}

        //put方法的细节：添加/覆盖
        //在添加元素的时候，如果键不存在，那么直接添加键值对对象到map集合中，返回值返回null；
        //在添加元素的时候，如果键存在，那么会把原有的键值对对象覆盖，返回被覆盖的键值对对象的值
        String put1 = map.put("孙策", "大乔");//键存在，原来的值“小乔”被“大乔”覆盖，返回值返回被覆盖的键值对对象的值“小乔”
        String put2 = map.put("吕布", "貂蝉");//键不存在，返回值返回null
        System.out.println("集合中键“孙策”存在的返回值：" + put1);    //小乔
        System.out.println("集合中键“吕布”不存在的返回值：" + put2);    //null
        System.out.println("删除元素的集合：" + map);  //{李白=王昭君, 吕布=貂蝉, 刘备=孙尚香, 孙策=大乔, 孙悟空=露娜, 亚瑟=安琪拉, 周瑜=小乔}


        System.out.println("========================= 根据键删除键值对元素  =========================");
        //2.根据键删除键值对元素
        //细节：返回值返回的是被删除的键值对对象的值
        String removeResult = map.remove("亚瑟");
        System.out.println("根据键“亚瑟“删除键值对元素的返回值：" + removeResult);    //安琪拉
        System.out.println("根据键删除键值对元素的集合：" + map);    //{李白=王昭君, 吕布=貂蝉, 刘备=孙尚香, 孙策=大乔, 孙悟空=露娜, 周瑜=小乔}


        System.out.println("=========================== 移除所有的键值对元素 ============================");
        //3.移除所有的键值对元素
        //map.clear();
        System.out.println("移除所有的键值对元素的集合：" + map);     //{}


        System.out.println("========================== 判断集合是否包含指定的键  ============================");
        //4.判断集合是否包含指定的键
        boolean containsKey1 = map.containsKey("孙策");
        boolean containsKey2 = map.containsKey("老夫子");
        System.out.println("集合中是否存在键“孙策”：" + containsKey1);       //true
        System.out.println("集合中是否存在键“老夫子”：" + containsKey2);       //false
        System.out.println("判断集合是否包含指定的键的集合：" + map);        //{李白=王昭君, 吕布=貂蝉, 刘备=孙尚香, 孙策=大乔, 孙悟空=露娜, 周瑜=小乔}


        System.out.println("=========================== 判断集合是否包含指定的值  =============================");
        //5.判断集合是否包含指定的值
        boolean containsValue1 = map.containsValue("貂蝉");
        boolean containsValue2 = map.containsValue("赵云");
        System.out.println("集合中是否存在值“貂蝉”：" + containsValue1);       //true
        System.out.println("集合中是否存在值“赵云”：" + containsValue2);       //false
        System.out.println("判断集合是否包含指定的值的集合：" + map);           //{李白=王昭君, 吕布=貂蝉, 刘备=孙尚香, 孙策=大乔, 孙悟空=露娜, 周瑜=小乔}


        System.out.println("=========================== 判断集合是否为空  ============================");
        //6.判断集合是否为空
        boolean empty1 = map.isEmpty();
        System.out.println("判断集合是否为空:" + empty1);          //false
        System.out.println("判断集合是否为空的集合：" + map);       //{李白=王昭君, 吕布=貂蝉, 刘备=孙尚香, 孙策=大乔, 孙悟空=露娜, 周瑜=小乔}


        System.out.println("========================== 集合的长度  ===========================");
        //7.集合的长度，也就是集合中键值对的个数
        int size = map.size();
        System.out.println("集合的长度：" + size);             //6
        System.out.println("判断集合的长度的集合：" + map);      //{李白=王昭君, 吕布=貂蝉, 刘备=孙尚香, 孙策=大乔, 孙悟空=露娜, 周瑜=小乔}
    }
}

4. 输出结果

1. 添加元素
   
2. 根据键删除键值对元素
   
3. 移除所有的键值对元素
   
4. 判断集合是否包含指定的键
   
5. 判断集合是否包含指定的值
   
6. 判断集合是否为空
   
7. 集合的长度
   

5. 注意事项

1. 键的唯一性：Map中的键是唯一的，当插入一个已存在的键时，新的值会覆盖旧的值。因此，在使用Map时需要保证键的唯一性，否则可能导致数据被覆盖或混乱。

2. 重写hashCode和equals方法：如果自定义类型作为键或值，需要重写该类型的hashCode和equals方法。这是因为Map在查找和比较键时，基于hashCode和equals进行操作。如果没有正确重写这两个方法，可能导致无法正确找到或比较键。

3. 并发访问：大多数Map实现类（如HashMap）不是线程安全的。如果在多线程环境下使用Map，需要进行合适的同步处理（如使用ConcurrentHashMap），或者使用线程安全的Map实现类（如Hashtable）。

4. 性能考虑：不同的Map实现类在性能方面可能存在差异，例如HashMap的查询和插入速度比较快，但迭代顺序不确定；而TreeMap则提供了按照键排序的功能，但性能可能略低。因此，在选择Map实现类时，需要根据具体需求和场景综合考虑性能因素。

5. 使用合适的泛型：Map接口是一个泛型接口，在使用时应指定键和值的具体类型，并进行类型安全的操作。这可以避免运行时的类型异常，并增加代码的可读性和可维护性。

6. 适当使用null键和null值：Map允许使用null作为键或值，但需要注意空指针异常。在使用含有null键的Map时，需要特别小心对键进行查找和比较的操作。