Java基础：集合：Map接口的具体介绍与使用

﹏ヽ暗。殇╰゛Y 2023-10-05 18:55 22阅读 0赞

> **我是 ABin-阿斌：写一生代码，创一世佳话，筑一揽芳华。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。**  
> ![在这里插入图片描述][01244a35a05f9070bf77418374331efc.png_pic_center]

# 一、概述 #

*  **Map** 与 **Collection** 并列存在。用于保存具有**映射关系**的数据：**key-value**
 *  **Map** 中的 **key** 和 **value** 都可以是任何引用类型的数据
 *  **Map** 中的 **key** 用 **Set** 来存放，**不允许重复**，即同一个 **Map** 对象所对应的类，须重写 **hashCode()** 和 **equals()** 方法
 *  常用 **String** 类作为 **Map** 的【键】
 *  **key** 和 **value** 之间存在单向一对一关系，即通过指定的 **key** 总能找到唯一的、确定的 **value**
 *  **Map** 接口的常用实现类：**HashMap**、**TreeMap**、**LinkedHashMap** 和 **Properties**。其中，**HashMap** 是 **Map** 接口使用频率最高的实现类。

## 一（2）Map接口常用方法 ##

##### 添加、删除、修改操作： #####

*  **Object put(Object key,Object value)：** 将指定 **key-value** 添加到(或修改)当前 **map** 对象中
 *  **void putAll(Map m)：** 将 **m** 中的所有 **key-value** 对存放到当前 **map** 中
 *  **Object remove(Object key)：** 移除指定 **key** 的 **key-value** 对，并返回 **value**
 *  **void clear()：** 清空当前 **map** 中的所有数据

#### 元素查询的操作： ####

*  **Object get(Object key)：** 获取指定 **key** 对应的 **value**
 *  **boolean containsKey(Object key)：** 是否包含指定的 **key**
 *  **boolean containsValue(Object value)：** 是否包含指定的 **value**
 *  **int size()：** 返回 **map** 中 **key-value** 对的个数
 *  **boolean isEmpty()：** 判断当前 **map** 是否为空
 *  **boolean equals(Object obj)：** 判断当前 **map** 和参数对象 **obj** 是否相等

#### 元视图操作的方法： ####

*  **Set keySet()：** 返回所有 **key** 构成的 **Set** 集合
 *  **Collection values()：** 返回所有 **value** 构成的 **Collection** 集合
 *  **Set entrySet()：** 返回所有 **key-value** 对构成的 **Set** 集合

### 常用方法代码演示： ###

public class MapTest {
        
        /**
         * 添加、删除、修改操作：
         * Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
         * void putAll(Map m):将m中的所有key-value对存放到当前map中
         * Object remove(Object key)：移除指定key的key-value对，并返回value
         * void clear()：清空当前map中的所有数据
         */
        @Test
        public void test01() {
        
            HashMap map = new HashMap(16);
            map.put("张三", 22);
            map.put("李四", 23);
            map.put("王五", 24);
            map.put("赵六", 25);
            map.put("小红", 26);
            map.put("小明", 27);
            map.put("小刚", 28);
            System.out.println(map);
    
            //putAll(Map m):将m中的所有key-value对存放到当前map中
            HashMap map01 = new HashMap(16);
            map01.putAll(map);
            System.out.println(map01);
    
            //remove(Object key)：移除指定key的key-value对，并返回value
            Object obj = map.remove("小红");
            System.out.println(obj);
            System.out.println(map);
    
            //clear()：清空当前map中的所有数据
            map.clear();
            System.out.println("移除后的Map为：" + map);
        }
    
        /**
         * 元素查询的操作：
         * Object get(Object key)：获取指定key对应的value
         * boolean containsKey(Object key)：是否包含指定的key
         * boolean containsValue(Object value)：是否包含指定的value
         * int size()：返回map中key-value对的个数
         * boolean isEmpty()：判断当前map是否为空
         * boolean equals(Object obj)：判断当前map和参数对象obj是否相等
         */
    
        @Test
        public void test02() {
        
            HashMap map = new HashMap(16);
            map.put("马云", 57);
            map.put("马华腾", 50);
            map.put("李彦宏", 53);
            map.put("刘强东", 48);
            map.put("丁磊", 50);
            map.put("王兴", 42);
            map.put("张一鸣", 42);
            map.put("王志东", 54);
            map.put("黄峥", 41);
            map.put("周鸿祎", 51);
            System.out.println(map);
    
            //get(Object key)：获取指定key对应的value
            System.out.println(map.get("马云"));
    
            //containsKey(Object key)：是否包含指定的key
            boolean containsKey = map.containsKey("刘强东");
            System.out.println(containsKey);
    
            //containsValue(Object value)：是否包含指定的value
            boolean containsValue = map.containsValue(53);
            System.out.println(containsValue);
    
            //size()：返回map中key-value对的个数
            System.out.println("Map的个数为：" + map.size());
    
            map.clear();
            //isEmpty()：判断当前map是否为空
            System.out.println(map.isEmpty());
    
            //equals(Object obj)：判断当前map和参数对象obj是否相等
            HashMap map1 = new HashMap<>(16);
            map1.put("马云", 57);
            map1.put("马华腾", 50);
            map1.put("李彦宏", 53);
            map1.put("刘强东", 48);
            map1.put("丁磊", 50);
            map1.put("王兴", 42);
            map1.put("张一鸣", 42);
            map1.put("王志东", 54);
            map1.put("黄峥", 41);
            map1.put("周鸿祎", 51);
            System.out.println(map.equals(map1));
        }
    
        /**
         * 元视图操作的方法：
         * Set keySet()：返回所有key构成的Set集合
         * Collection values()：返回所有value构成的Collection集合
         * Set entrySet()：返回所有key-value对构成的Set集合
         */
        @Test
        public void test03() {
        
            HashMap map = new HashMap<>(16);
            map.put("马云", 57);
            map.put("马华腾", 50);
            map.put("李彦宏", 53);
            map.put("刘强东", 48);
            map.put("丁磊", 50);
            map.put("王兴", 42);
            map.put("张一鸣", 42);
            map.put("王志东", 54);
            map.put("黄峥", 41);
            map.put("周鸿祎", 51);
            System.out.println(map);
    
            //keySet()：返回所有key构成的Set集合
            Set set = map.keySet();
            Iterator iterator = set.iterator();
            while (iterator.hasNext()) {
        
                System.out.println(iterator.next());
            }
            System.out.println();
    
            //values()：返回所有value构成的Collection集合
            Collection values = map.values();
            for (Object value : values) {
        
                System.out.println(value);
            }
            System.out.println();
    
            //entrySet()：返回所有key-value对构成的Set集合
            //方式一：
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()) {
        
                Object next = iterator1.next();
                //entrySet集合中的元素都是entry
                Map.Entry entry = (Map.Entry) next;
                System.out.println(entry.getKey() + "===============" + entry.getValue());
            }
            System.out.println();
    
            //方式二：
            Set keySet = map.keySet();
            Iterator iterator2 = keySet.iterator();
            while (iterator2.hasNext()){
        
                Object key = iterator2.next();
                Object value = map.get(key);
                System.out.println(key + "========" + value);
            }
        }
    }

## 二、Map 实现类之一：HashMap ##

*  **HashMap** 是 **Map** 接口**使用频率最高**的实现类。
 *  允许使用 **null** 键和 **null** 值，与 **HashSet** 一样，不保证映射的顺序。
 *  所有的 **key** 构成的集合是 **Set**：无序的、不可重复的。所以，**key** 所在的类要重写：**equals() 和 hashCode()**
 *  所有的 **value** 构成的集合是 **Collection**：无序的、可以重复的。所以，**value** 所在的类要重写：**equals()**  
    一个 **key-value** 构成一个 **entry**
 *  所有的 **entry** 构成的集合是 **Set**：无序的、不可重复的
 *  **HashMap** 判断两个 **key** 相等的标准是：两个 **key** 通过 **equals()** 方法返回 **true**，**hashCode** 值也相等。
 *  **HashMap** 判断两个 **value** 相等的标准是：两个 **value** 通过 **equals()** 方法返回 **true**

### HashMap的存储结构 ###

**JDK7版本的结构图：**

![在这里插入图片描述][5a7319933d6ad52e5f06b6c537a17db7.png_pic_center]

**JDK8版本的结构图：**

![在这里插入图片描述][213b387058d398ac4dc86a6c694f8d49.png_pic_center]

## 三、底层源码分析： ##

### **JDK7 及之前版本** ###

*  **HashMap** 的内部存储结构其实是数组和链表的结合。当实例化一个 **HashMap** 时，系统会创建一个长度为 **Capacity** 的 **Entry** 数组，这个长度在哈希表中被称为容量(**Capacity**)，在这个数组中可以存放元素的位置我们称之为【桶】(**bucket**)，每个 **bucket** 都有自己的索引，系统可以根据索引快速的查找 **bucket** 中的元素。
 *  每个 **bucket** 中存储一个元素，即一个 **Entry** 对象，但每一个 **Entry** 对象可以带一个引用变量，用于指向下一个元素，因此，在一个桶中，就有可能生成一个 **Entry** 链。而且新添加的元素作为链表的 **head**。
 *  **添加元素的过程（JDK7及之前版本）：**
    
     *  **HashMap map = new HashMap()** 当我们实例化以后，底层创建了长度是 **16** 的一维数组 **Entry\[\] table**。此时可能已经执行了多次的 **put**。

**源码展示：**

**IDEA**快捷键：**Ctrl+O** 搜索 **HashMap()** 方法即可看到

*  ![在这里插入图片描述][e603f99ad8177e607eb1c69d4d4ec072.png_pic_center]

选中点击 **this()** 方法即可看到如下代码

*  ![在这里插入图片描述][bf0120b713234eaa95a48570d78c4f6d.png_pic_center]  
    ![在这里插入图片描述][ef3659eacef8e9a833baaea7fb08aea4.png_pic_center]

**IDEA**快捷键：**Ctrl+O** 搜索 **put()** 方法即可看到

*  ![在这里插入图片描述][fa11fe65f64f31aa04749ca61261c629.png_pic_center]

我们一起来看看它是如何计算 **hash** 值的

*  ![在这里插入图片描述][0c93579812c55c1a8c78cc524a9705b9.png_pic_center]

添加的步骤

*  ![在这里插入图片描述][90241873e689efca83f1f1477d1d504e.png_pic_center]
 *  ![在这里插入图片描述][eccc6cff95e1542e34e50c2b1d33ef72.png_pic_center]
 *  
 *  当我们向 **HashMap** 中 **put** 的时候，首先，我们会调用 **entry1(key1，value1)**，然后开始计算 **entry1** 中 **key1** 的哈希值（根据 **key1** 所在类的 **hashCode()** 计算得到），此哈希值经过某种算法计算以后，得到在 **Entry** 数组中的存放位置。如果此位置上的数据为空，此时的 **entry1** 添加成功。【**情况1**】
 *  如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)，比较 **key1**和已经存在的一个或多个数据的哈希值：如果 **key1** 的哈希值与已经存在的数据的哈希值都不相同，此时 **entry1** 添加成功。【**情况2**】
 *  如果 **key1** 的哈希值和已经存在的某一个数据 **(key2-value2)** 的哈希值相同，继续比较：调用 **key1** 所在类的 **equals(key2)** 方法，比较：如果 **equals()** 返回 **false**：此时 **entry1** 添加成功。【**情况3**】
 *  如果 **equals()** 返回 **true**：使用 **value1** 替换 **value2**。
 *  注意：
    
     *  关于【**情况2**】和【**情况3**】：此时 **entry1** 和原来的数据以链表的方式存储。
     *  在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。**默认的扩容方式：** 扩容为原来容量的 **2 倍**，并将原的数据复制过来。

#### HashMap 的扩容： ####

当 **HashMap** 中的元素越来越多的时候，**hash** 冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对 **HashMap** 的数组进行扩容，而在 **HashMap** 数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是 **resize**。

#### 那么HashMap什么时候进行扩容呢？ ####

当 **HashMap** 中的元素个数超过数组大小(数组总大小 **length**，不是数组中个数 **size**) \* **loadFactor**时，就会进行数组扩容，**loadFactor** 的默认值 **(DEFAULT\_LOAD\_FACTOR)为 0.75**，这是一个折中的取值。也就是说，默认情况下，数组大小 **(DEFAULT\_INITIAL\_CAPACITY)为 16**，那么当 **HashMap** 中元素个数超过 **16\*0.75=12**（这个值就是代码中的 **threshold** 值，也叫做临界值）的时候，就把数组的大小扩展为 **2\*16=32**，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知 **HashMap** 中元素的个数，那么预设元素的个数能够有效的提高 **HashMap** 的性能。

### **JDK8 版本** ###

*  **HashMap** 的内部存储结构其实是 **数组+链表+树的结合**。当实例化一个 **HashMap** 时，会初始化**initialCapacity 和 loadFactor**，在 **put** 第一对映射关系时，系统会创建一个长度为 **initialCapacity 的 Node** 数组，这个长度在哈希表中被称为容量(**Capacity**)，在这个数组中可以存放元素的位置我们称之为【桶】(**bucket**)，每个 **bucket** 都有自己的索引，系统可以根据索引快速的查找 **bucket** 中的元素。
 *  每个 **bucket** 中存储一个元素，即一个 **Node** 对象，但每一个 **Node** 对象可以带一个引用变量 **next**，用于指向下一个元素，因此，在一个桶中，就有可能生成一个 **Node** 链。也可能是一个一个 **TreeNode** 对象，每一个 **TreeNode** 对象可以有两个叶子结点 **left** 和 **right**，因此，在一个桶中，就有可能生成一个 **TreeNode** 树。而新添加的元素作为链表的 **last**，或树的叶子结点。

#### 那么HashMap什么时候进行扩容和树形化呢？ ####

*  当 **HashMap** 中的元素个数超过数组大小 **(数组总大小 length，不是数组中个数 size) \* loadFactor** 时，就会进行数组扩容，**loadFactor** 的默认值 **(DEFAULT\_LOAD\_FACTOR)为0.75**，这是一个折中的取值。也就是说，默认情况下，数组大小 **(DEFAULT\_INITIAL\_CAPACITY)为16**，那么当 **HashMap** 中元素个数超过 **16\*0.75=12**（**这个值就是代码中的 threshold 值，也叫做临界值)** 的时候，就把数组的大小扩展为 **2\*16=32**，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知 **HashMap** 中元素的个数，那么预设元素的个数能够有效的提高 **HashMap** 的性能。
 *   当 **HashMap** 中的其中一个链的对象个数如果达到了 **8** 个，此时如果 **capacity** 没有达到 **64**，那么 **HashMap** 会先扩容解决，如果已经达到了 **64**，那么这个链会变成树，结点类型由 **Node** 变成 **TreeNode** 类型。当然，如果当映射关系被移除后，下次 **resize** 方法时判断树的结点个数低于 **6** 个，也会把树再转为链表。

**源码展示：**

刚开始并没有直接创建为 **16** 的数组

*  ![在这里插入图片描述][b4054b09d399419234f0a9b0d8359d39.png_pic_center]

**JDK8** 底层的数组用的是 ：**Node\[\]**，而非 **Entry\[\]**

*  ![在这里插入图片描述][dc3f4734ac043aeb5073181a2e757a55.png_pic_center]

进入 **Node** 方法 我们可以看到

*  ![在这里插入图片描述][01997ee48c0cac6d5a4425bcdc502620.png_pic_center]

首次调用 **put()** 方法时，底层创建长度为 **16** 的数组，而并非一进来就开始创建。

*  ![在这里插入图片描述][08395b6c35cdc7fa9519ee187ffc130f.png_pic_center]

计算**hash** 值

*  ![在这里插入图片描述][546807903c1b05bf895e353d37c14ab9.png_pic_center]

**put()** 方法底层源码

*  ![在这里插入图片描述][cc62655a9e83591b89652589c880c62f.png_pic_center]

我们再通过 **resize()** 方法看看它是如何扩容的

*  ![在这里插入图片描述][4a437729e4fc30dc447a3ca14b044255.png_pic_center]

#### HashMap源码中的重要常量： ####

*  **DEFAULT\_INITIAL\_CAPACITY :****HashMap** 的默认容量，**16**
 *  **MAXIMUM\_CAPACITY ：** **HashMap** 的最大支持容量，**2 ^ 30**
 *  **DEFAULT\_LOAD\_FACTOR：** **HashMap** 的默认加载因子
 *  **TREEIFY\_THRESHOLD：** **Bucket** 中链表长度大于该默认值，转化为红黑树
 *  **UNTREEIFY\_THRESHOLD：** **Bucket** 中红黑树存储的 **Node** 小于该默认值，转化为链表
 *  **MIN\_TREEIFY\_CAPACITY：** 桶中的 **Node** 被树化时最小的 **hash** 表容量。（当桶中 **Node** 的数量大到需要变红黑树时，若 **hash** 表容量小于 **MIN\_TREEIFY\_CAPACITY** 时，此时应执行 **resize** 扩容操作这个 **MIN\_TREEIFY\_CAPACITY** 的值至少是 **TREEIFY\_THRESHOLD** 的 **4** 倍。）
 *  **table：** 存储元素的数组，总是 **2** 的 **n** 次幂
 *  **entrySet：**存储具体元素的集
 *  **size：HashMap** 中存储的键值对的数量
 *  **modCount：** **HashMap** 扩容和结构改变的次数。
 *  **threshold：**扩容的临界值，**= 容量 \* 填充因子**
 *  **loadFactor：**填充因子

#### 关于映射关系的 key 是否可以修改？答案：不要修改 ####

映射关系存储到 **HashMap** 中会存储 **key** 的 **hash** 值，这样就不用在每次查找时重新计算每一个 **Entry** 或 **Node**（**TreeNode**）的 **hash** 值了，因此如果已经 **put** 到 **Map** 中的映射关系，再修改 **key** 的属性，而这个属性又参与 **hashcode** 值的计算，那么会导致匹配不上。

### 总结 ###

**JDK8 相较于 JDK7 在底层实现方面的不同：**

*  **HashMap map = new HashMap();** 底层没有创建一个长度为 **16** 的数组
 *  **JDK8** 底层的数组是：**Node\[\]**，而非 **Entry\[\]**
 *  首次调用 **put()** 方法时，底层创建长度为 **16** 的数组
 *  **JDK7 底层结构只有：** 数组 + 链表。**JDK8中底层结构：** 数组 + 链表 + 红黑树。 
    
     *  形成链表时，七上八下（**JDK7：** 新的元素指向旧的元素。**JDK8：** 旧的元素指向新的元素）
     *  当数组的某一个索引位置上的元素以链表形式存在的数据个数 **> 8** 且当前数组的长度 **> 64** 时，此时此索引位置上的所数据改为使用红黑树存储。

### 面试题：负载因子值的大小，对 HashMap 有什么影响 ###

*   负载因子的大小决定了HashMap的数据密度。
 *  负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,造成查询或插入时的比较次数增多，性能会下降。
 *  负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
 *  按照其他语言的参考及研究经验，会考虑将负载因子设置为 0.7~0.75，此时平均检索长度接近于常数。

## 四、Map 实现类之二：LinkedHashMap ##

*  **LinkedHashMap** 是 **HashMap** 的子类
 *  在 **HashMap** 存储结构的基础上，使用了一对双向链表来记录添加元素的顺序
 *  与 **LinkedHashSet** 类似，**LinkedHashMap** 可以维护 **Map** 的迭代顺序：迭代顺序与 **Key-Value** 对的插入顺序一致。

### HashMap中的内部类：Node ###

![在这里插入图片描述][6506e4a2819d3025e2debd0387538323.png_pic_center]

### LinkedHashMap中的内部类：Entry ###

![在这里插入图片描述][8c93bb2b9e8a040219596c8e7117dacb.png_pic_center]

### 何时使用 LinkedHashMap？答案：当我们需要平凡遍历的时候 ###

## 五、Map实现类之三：TreeMap ##

*  **TreeMap** 存储 **Key-Value** 对时，需要根据 **key-value** 对进行排序。**TreeMap** 可以保证所有的 **Key-Value** 对处于**有序**状态。
 *  **TreeSet** 底层使用 **红黑树** 结构存储数据

### TreeMap 的 Key 的排序： ###

*  **自然排序：** **TreeMap** 的所有的 **Key** 必须实现 **Comparable** 接口，而且所有的 **Key** 应该是同一个类的对象，否则将会抛出 **ClasssCastException**
 *  **定制排序：** 创建 **TreeMap** 时，传入一个 **Comparator** 对象，该对象负责对 **TreeMap** 中的所有 **key** 进行排序。此时不需要 **Map** 的 **Key** 实现 **Comparable** 接口  
    **TreeMap** 判断 两个 **key** 相等的标准：两个 **key** 通过 **compareTo()** 方法或者 **compare()** 方法返回 **0**。

### 代码演示： ###

public class User implements Comparable{
        
        private String name;
        private int age;
        
        //略：无参构造、有参构造、get\set\toString
    
        @Override
        public boolean equals(Object o) {
        
            System.out.println("User equals()....");
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            User user = (User) o;
    
            if (age != user.age) return false;
            return name != null ? name.equals(user.name) : user.name == null;
        }
    
        @Override
        public int hashCode() {
         //return name.hashCode() + age;
            int result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            return result;
        }
    
        //按照姓名从大到小排列,年龄从小到大排列
        @Override
        public int compareTo(Object o) {
        
            if(o instanceof User){
        
                User user = (User)o;
                //从大到小
               //return -this.name.compareTo(user.name);
                int compare = -this.name.compareTo(user.name);
                if(compare != 0){
        
                    return compare;
                }else{
        
                    return Integer.compare(this.age,user.age);
                }
            }else{
        
                throw new RuntimeException("输入的类型不匹配");
            }
    
        }
    }

public class TreeMapTest {
        
    
        //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
        //因为要按照key进行排序：自然排序 、定制排序
        //自然排序
        @Test
        public void test1(){
        
            TreeMap map = new TreeMap();
            User u1 = new User("Tom",23);
            User u2 = new User("Jerry",32);
            User u3 = new User("Jack",20);
            User u4 = new User("Rose",18);
    
            map.put(u1,98);
            map.put(u2,89);
            map.put(u3,76);
            map.put(u4,100);
    
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()){
        
                Object obj = iterator1.next();
                Map.Entry entry = (Map.Entry) obj;
                System.out.println(entry.getKey() + "---->" + entry.getValue());
    
            }
        }
    
        //定制排序
        @Test
        public void test2(){
        
            TreeMap map = new TreeMap(new Comparator() {
        
                @Override
                public int compare(Object o1, Object o2) {
        
                    if(o1 instanceof User && o2 instanceof User){
        
                        User u1 = (User)o1;
                        User u2 = (User)o2;
                        return Integer.compare(u1.getAge(),u2.getAge());
                    }
                    throw new RuntimeException("输入的类型不匹配！");
                }
            });
            User u1 = new User("Tom",23);
            User u2 = new User("Jerry",32);
            User u3 = new User("Jack",20);
            User u4 = new User("Rose",18);
    
            map.put(u1,98);
            map.put(u2,89);
            map.put(u3,76);
            map.put(u4,100);
    
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()){
        
                Object obj = iterator1.next();
                Map.Entry entry = (Map.Entry) obj;
                System.out.println(entry.getKey() + "---->" + entry.getValue());
    
            }
        }
    }

## 六、Map实现类之四：Hashtable ##

*  **Hashtable** 是个古老的 **Map** 实现类，**JDK1.0** 就提供了。不同于 **HashMap**，**Hashtable** 是线程安全的。
 *  **Hashtable** 实现原理和 **HashMap** 相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
 *  与 **HashMap** 不同，**Hashtable** 不允许使用 **null** 作为 **key** 和 **value**
 *  与 **HashMap** 一样，**Hashtable** 也不能保证其中 **Key-Value** 对的顺序
 *  **Hashtable** 判断两个 **key** 相等、两个 **value** 相等的标准，与 **HashMap** 一致。

## 七、Map实现类之五：Properties ##

*  **Properties** 类是 **Hashtable** 的子类，该对象用于处理属性文件
 *  由于属性文件里的 **key、value** 都是字符串类型，所以**Properties** 里的 **key** 和 **value** 都是字符串类型。
 *  存取数据时，建议使用 **setProperty(String key,String value) 方法 和 getProperty(String key) 方法**

### 代码演示： ###

public class PropertiesTest {
        
    
        //Properties:常用来处理配置文件。key和value都是String类型
        public static void main(String[] args)  {
        
            FileInputStream fis = null;
            try {
        
                Properties pros = new Properties();
    
                fis = new FileInputStream("abin.properties");
                pros.load(fis);//加载流对应的文件
    
                String name = pros.getProperty("name");
                String city = pros.getProperty("city");
    
                System.out.println("name = " + name + ", city= " + city);
            } catch (IOException e) {
        
                e.printStackTrace();
            } finally {
        
                if(fis != null){
        
                    try {
        
                        fis.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
    
                }
            }
        }
    }

## 七、Collections工具类 ##

*  **Collections** 是一个操作 **Set**、**List** 和 **Map** 等集合的工具类
 *  **Collections** 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
 *  **排序操作：**（均为 **static** 方法）
    
     *  **reverse(List)：** 反转 **List** 中元素的顺序
     *  **shuffle(List)：** 对 **List** 集合元素进行随机排序
     *  **sort(List)：** 根据元素的自然顺序对指定 **List** 集合元素按升序排序
     *  **sort(List，Comparator)：** 根据指定的 **Comparator** 产生的顺序对 **List** 集合元素进行排序
     *  **swap(List，int， int)：** 将指定 list 集合中的 i 处元素和 j 处元素进行交换

### Collections常用方法 ###

#### 查找、替换 ####

*  **Object max(Collection)：** 根据元素的自然顺序，返回给定集合中的最大元素
 *  **Object max(Collection，Comparator)：** 根据 **Comparator** 指定的顺序，返回给定集合中的最大元素
 *  **Object min(Collection)**
 *  **Object min(Collection，Comparator)**
 *  **int frequency(Collection，Object)：** 返回指定集合中指定元素的出现次数
 *  **void copy(List dest,List src)：**将 **src** 中的内容复制到 **dest** 中
 *  **boolean replaceAll(List list，Object oldVal，Object newVal)：**使用新值替换 **List** 对象的所有旧值

#### Collections常用方法：同步控制 ####

**Collections** 类中提供了多个 **synchronizedXxx() 方法**，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

![在这里插入图片描述][0d1bf71beb965a4169b7d5ad150fce21.png_pic_center]

#### Collection 和 Collections的区别 ####

*  **Collection** 是集合类的上级接口，继承于他的接口主要有 **Set** 和 **List**
 *  **Collections** 是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

#### Collections 常用方法代码演示: ####

public class CollectionsTest {
        
    
        @Test
        public void test01() {
        
            List list = new ArrayList<>();
            list.add(1001);
            list.add(1002);
            list.add(1003);
            list.add(1000);
            list.add(1004);
            list.add(1005);
            list.add(1006);
    
            //1、反转 List 中元素的顺序
            //Collections.reverse(list);
    
            //2、对 List 集合元素进行随机排序
            //Collections.shuffle(list);
    
            //3、sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
            //3.1、sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
            //Collections.sort(list);
    
            //4、swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
            Collections.swap(list, 3, 0);
    
            //5、int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
            int frequency = Collections.frequency(list, 1006);
    
            System.out.println("该值的出现次数为：" + frequency);
    
    
            System.out.println(list);
        }
    
        @Test
        public void test02(){
        
            List list = new ArrayList();
            list.add(222);
            list.add(333);
            list.add(555);
            list.add(666);
            list.add(777);
            list.add(888);
    
            //方式一：
            //1、void copy(List dest,List src)：将src中的内容复制到dest中
            //List dest  = new ArrayList();
            //Collections.copy(dest,list); //报异常：IndexOutOfBoundsException("Source does not fit in dest")
    
            //方式二：
            Object[] array;
            List dest = Arrays.asList(new Object[list.size()]);
            System.out.println("dest集合的元素长度为：" + dest.size());
            Collections.copy(dest, list);
            System.out.println(dest);
    
    
    //        Collections 类中提供了多个 synchronizedXxx() 方法，
    //        该方法可使将指定集合包装成线程同步的集合，从而可以解决
    //        多线程并发访问集合时的线程安全问题
    
            //返回的list1即为线程安全的List
            List list1 = Collections.synchronizedList(list);
        }
    }

[01244a35a05f9070bf77418374331efc.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/01244a35a05f9070bf77418374331efc.png#pic_center
[5a7319933d6ad52e5f06b6c537a17db7.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/5a7319933d6ad52e5f06b6c537a17db7.png#pic_center
[213b387058d398ac4dc86a6c694f8d49.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/213b387058d398ac4dc86a6c694f8d49.png#pic_center
[e603f99ad8177e607eb1c69d4d4ec072.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/e603f99ad8177e607eb1c69d4d4ec072.png#pic_center
[bf0120b713234eaa95a48570d78c4f6d.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/bf0120b713234eaa95a48570d78c4f6d.png#pic_center
[ef3659eacef8e9a833baaea7fb08aea4.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/ef3659eacef8e9a833baaea7fb08aea4.png#pic_center
[fa11fe65f64f31aa04749ca61261c629.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/fa11fe65f64f31aa04749ca61261c629.png#pic_center
[0c93579812c55c1a8c78cc524a9705b9.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/0c93579812c55c1a8c78cc524a9705b9.png#pic_center
[90241873e689efca83f1f1477d1d504e.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/90241873e689efca83f1f1477d1d504e.png#pic_center
[eccc6cff95e1542e34e50c2b1d33ef72.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/eccc6cff95e1542e34e50c2b1d33ef72.png#pic_center
[b4054b09d399419234f0a9b0d8359d39.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/b4054b09d399419234f0a9b0d8359d39.png#pic_center
[dc3f4734ac043aeb5073181a2e757a55.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/dc3f4734ac043aeb5073181a2e757a55.png#pic_center
[01997ee48c0cac6d5a4425bcdc502620.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/01997ee48c0cac6d5a4425bcdc502620.png#pic_center
[08395b6c35cdc7fa9519ee187ffc130f.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/08395b6c35cdc7fa9519ee187ffc130f.png#pic_center
[546807903c1b05bf895e353d37c14ab9.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/546807903c1b05bf895e353d37c14ab9.png#pic_center
[cc62655a9e83591b89652589c880c62f.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/cc62655a9e83591b89652589c880c62f.png#pic_center
[4a437729e4fc30dc447a3ca14b044255.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/4a437729e4fc30dc447a3ca14b044255.png#pic_center
[6506e4a2819d3025e2debd0387538323.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/6506e4a2819d3025e2debd0387538323.png#pic_center
[8c93bb2b9e8a040219596c8e7117dacb.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/8c93bb2b9e8a040219596c8e7117dacb.png#pic_center
[0d1bf71beb965a4169b7d5ad150fce21.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/0d1bf71beb965a4169b7d5ad150fce21.png#pic_center