Java集合（四）之Map

短命女 2022-05-24 14:20 287阅读 0赞

## 一、Map接口 ##

#### 1.1 Map概述 ####

*  Map 的字面翻译是映射(地图就是一种映射)。将键映射到值的对象，一个映射不能包含重复的键  
    （**如果有添加有重复的键，后面的会覆盖掉前面的**，但是如果是自定义类型必须重写hashCode()和  
    equals()方法），每个键最多只能映射到一个值。
 *  Map是Java中提供的一种通用的元素存储方式，它是一种集合类。map集合类用于存储键值对  
    （“键”、“值”）即Map

#### 1.2 Map接口和Collection接口的不同 ####

*  Map是双列的,Collection是单列的
 *  Map的键唯一,Collection的子体系Set是唯一的
 *  Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效。
 *  Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素

#### 1.3 Map集合功能概述 ####

1）添加功能

V put(K key,V value):添加元素。
        如果键是第一次存储，就直接存储元素，返回null
        如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
     putAll(Map<? extends K,? extends V> m):将指定Map中的键值对复制到Map中

2）删除功能

void clear():移除所有的键值对元素
     V remove(Object key)：删除指定key所对应的键值对，返回可以所关联的value，如果key不存在，返回null

3）判断功能

boolean containsKey(Object key)：判断集合是否包含指定的键
    boolean containsValue(Object value):判断集合是否包含指定的值
    boolean isEmpty()：判断集合是否为空

4）获取功能

Set<Map.Entry<K,V>> entrySet():
     V get(Object key):根据键获取值
     Set<K> keySet():获取集合中所有键的集合
     Collection<V> values():获取集合中所有值的集合

5）长度功能

int size()：返回集合中的键值对的个数

Map中包含一个内部类：Entry。该类封装了一个键值对，它包含了三个方法：

Object getKey():返回该Entry里包含的key值。
    Object getValeu():返回该Entry里包含的value值。
    Object setValue(V value):设置该Entry里包含的value值，并返回新设置的value值。

#### 1.4 Map实例之遍历 ####

Map的遍历大体有3种：

*  遍历Map.entrySet()：它的每一个元素都是Map.Entry对象，这个对象中，  
    放着的就是Map中的某一对key-value。
 *  遍历Map.keySet()：它是Map中key值的集合，我们可以通过遍历这个集合  
    来读取Map中的元素。
 *  遍历Map.values()：它是Map中value的集合，我们可以直接通过这个集合  
    遍历Map中的值，却不能读取key。

举例一:Map集合的遍历之键找值  
思路：一是：获取所有键的集合。二是：遍历键的集合，获取到每一个键。三是：根据键找值。

package com.zyh.Collection.map;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class MapDemo_0010 {
    //    Map集合的遍历之键找值
        public static void main(String[] args) {
            Map<String,Integer> map = new HashMap<>();
            map.put("张三",34);
            map.put("美女",14);
            map.put("帅哥",24);
            map.put("流浪汉",74);
    
            /*方式一：使用迭代器
            Set<String> str = map.keySet();
            Iterator<String> it = str.iterator();
            while (it.hasNext()){
                String key = it.next();
                Integer value = map.get(key);
                System.out.println("key="+key+"——value="+value);
            }*/
    
            //方式二：使用增强for循环
            for (String key:map.keySet()){
                System.out.println("key="+key+"——value="+map.get(key));
            }
        }
    }

举例二：Map集合的遍历之键值对对象找键和值  
思路：  
 一是：获取所有键值对对象的集合。  
 二是：遍历键值对对象的集合，获取到每一个键值对对象。  
 三是：根据键值对对象找键和值。

package com.zyh.Collection.map;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class MapDemo_0011 {
        //Map集合的遍历之键值对对象找键和值
        public static void main(String[] args) {
            Map<String,Integer> map = new HashMap<>();
            map.put("张三",34);
            map.put("美女",14);
            map.put("帅哥",24);
            map.put("流浪汉",74);
    
            /*方式一：使用迭代器
            Set<Map.Entry<String, Integer>> entry = map.entrySet(); //获取所有的键值对象的集合
            Iterator<Map.Entry<String, Integer>> it = entry.iterator(); //获取迭代器
            while (it.hasNext()){
                Map.Entry<String, Integer> en = it.next();  //获取键值对对象
                String key = en.getKey();   //根据键值对对象获取键
                Integer value = en.getValue();  //根据键值对对象获取值
                System.out.println("key="+key+"——value="+value);
            }*/
            //方式二：使用增强for循环
            for (Map.Entry<String,Integer> en : map.entrySet()){
                String key = en.getKey();
                Integer value = en.getValue();
                System.out.println("key="+key+"——value="+value);
            }
    
        }
    }

## 二、HashMap ##

#### 2.1 HashMap概述 ####

*  HashMap 是一个**散列表**，它存储的内容是键值对(key-value)映射。它**存储的时候是无序的**。
 *  HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
 *  HashMap 的实现不是同步的，这意味着它**不是线程安全的**。它的**key、value都可以为null**。  
    此外，**HashMap中的映射不是有序的**。

在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构  
都可以用这两个基本结构来构造的，HashMap也不例外。  
**HashMap实际上是一个“链表的数组”的数据结构**，每个元素存放链表头结点的数组，即数组和链表的结合体。

HashMap注意事项：

*  HashMap底层维护一个数组，我们向HashMap中所放置的对象实际上是存储在该数组当中。
 *  当向HashMap中put一对键值时，它会根据key的hashCode值计算出一个位置，该位置就是  
    此对象准备往数组中存放的位置。

#### 2.2 实例：在HashMap中存储key为Student对象，value为String类型 ####

当键是自定义类型时怎么保证唯一性：**重写hashCode()和equals()方法**,这样我们在存储的时候  
如果有重复的键，后面的会覆盖前面的。

package com.zyh.Collection.map;
    
    import com.zyh.domain.Student;
    import java.util.HashMap;
    
    public class HashMapDemo_0010 {
        
        public static void main(String[] args) {
            HashMap<Student,String> hs = new HashMap<>();
            hs.put(new Student("张三",23),"上海");
            hs.put(new Student("张三",23),"上海");
            hs.put(new Student("李四",55),"深圳");
            hs.put(new Student("王五",78),"苏州");
            hs.put(new Student("赵六",89),"杭州");
    
            System.out.println(hs);
        }
    }

这里的话就会输出：

![wJ4MKOe.png][]  
分析：首先输出的都是无序的，为什么直接输出map就会打印呢？因为底层重写了toString方法。

![Vm2wPMJ.png][]  
查看之后它的父类重写了toString()方法

#### 2.3 HashMap的用法 ####

需求：统计字符串中每个字符出现的次数

String str = "aaaabbbcccccccccc";
                char[] arr = str.toCharArray();                        //将字符串转换成字符数组
                HashMap<Character, Integer> hm = new HashMap<>();    //创建双列集合存储键和值
    
                for(char c : arr) {                                    //遍历字符数组
                    if(!hm.containsKey(c)) {                        //如果不包含这个键
                        hm.put(c, 1);                                //就将键和值为1添加
                    }else {                                            //如果包含这个键
                        hm.put(c, hm.get(c) + 1);                    //就将键和值再加1添加进来
                    }
    
                    //hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
                    Integer i = !hm.containsKey(c) ? hm.put(c, 1) : hm.put(c, hm.get(c) + 1);
                            }
    
                for (Character key : hm.keySet()) {                    //遍历双列集合
                    System.out.println(key + "=" + hm.get(key));
                }

#### 2.4 LinkedHashMap ####

**特点：底层是链表实现的可以保证怎么存就怎么取**

举例：

import com.zyh.domain.Student;
    import java.util.LinkedHashMap;
    
    public class LinkedHashMapDemo_0010 {
        public static void main(String[] args) {
            LinkedHashMap<Student,String> lhs = new LinkedHashMap<>();
            lhs.put(new Student("张三",23),"上海");
            lhs.put(new Student("李四",55),"深圳");
            lhs.put(new Student("王五",78),"苏州");
            lhs.put(new Student("赵六",89),"杭州");
    
            System.out.println(lhs);
        }
    }

结果：

![byXev78.png][]

## 三、TreeMap ##

#### 3.1 TreeMap概述 ####

TreeMap底层是二叉树数据结构,线程不同步,可用于给Map集合中的键进行排序。  
注意：

*  1）用作key的对象必须实现hashCode和equals方法。
 *  2）不能保证其中的键值对的顺序
 *  3）尽量不要使用可变对象作为它们的key值。

SortedMap接口和TreeMap类的关系

*  SortedMap接口是Map的子接口,其进一步提供对于键的排序功能。
 *  TreeMap类就是SortedMap接口的实现类。
 *  TreeMap可以对key值进行自然排序或者比较器排序,其用法和TreeSet是一致的。

#### 3.2 举例说明TreeMap排序问题 ####

package com.zyh.Collection.map;
    
    import com.zyh.domain.Student;
    import java.util.TreeMap;
    
    public class TreeMapDemo_0010 {
        
        public static void main(String[] args) {
            TreeMap<Student,String> tm = new TreeMap<>();
            tm.put(new Student("张三",23),"上海");
            tm.put(new Student("李四",18),"深圳");
            tm.put(new Student("王五",78),"苏州");
            tm.put(new Student("赵六",66),"杭州");
            System.out.println(tm);
        }
    }

当我们执行的时候会出错  
![UszC0Kx.png][]  
因为key是自定义对象不知道怎么排序，所以这里要实现Comparable接口，重写compareTo方法，  
或者给TreeMap的构造方法中声明一个比较器。

*  方式一：实现Comparable接口，重写compareTo方法  
    实现Comparable接口:

public class Student implements Comparable<Student>{

重写compareTo方法：  
![6CtMAQ3.png][]  
结果：按年龄排序  
![KAuNwaQ.png][]

*  方式二：给TreeMap的构造方法中声明一个比较器（测试前把前面Student中的删除掉）

package com.zyh.Collection.map;
    
    import com.zyh.domain.Student;
    import java.util.Comparator;
    import java.util.TreeMap;
    
    public class TreeMapDemo_0010 {
        
        public static void main(String[] args) {
            TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
                @Override
                public int compare(Student s1, Student s2) {
                    int num = s1.getAge()-s2.getAge();
                    //s1.getName().compareTo(s2.getName())这里的compareTo方法是String类中的方法
                    return num==0?s1.getName().compareTo(s2.getName()):num;
                }
            });
            tm.put(new Student("张三",23),"上海");
            tm.put(new Student("李四",18),"深圳");
            tm.put(new Student("王五",78),"苏州");
            tm.put(new Student("赵六",66),"杭州");
            System.out.println(tm);
        }
    }

## 四、HashMap与HashTable的区别 ##

*  同步性  
    **Hashtable是同步的**，这个类中的一些方法保证了**Hashtable中的对象是线程安全的**。  
    而**HashMap则是异步的**，因此**HashMap中的对象并不是线程安全的**。  
    因为同步的要求会影响执行的效率，所以**如果你不需要线程安全的集合那么使用HashMap**是  
    一个很好的选择，这样可以避免由于同步带来的不必要的性能开销，从而提高效率。
 *  值  
    HashMap可以让你**将空值作为一个表的条目的key或value**，但是**Hashtable是不能放入空值的**。  
    HashMap\*\*最多只有一个key值为null，但可以有无数多个value值为null\*\*。
 *  性能  
    HashMap的性能最好，HashTable的性能是最差（因为它是同步的）

[wJ4MKOe.png]: https://i.imgur.com/wJ4MKOe.png
[Vm2wPMJ.png]: https://i.imgur.com/Vm2wPMJ.png
[byXev78.png]: https://i.imgur.com/byXev78.png
[UszC0Kx.png]: https://i.imgur.com/UszC0Kx.png
[6CtMAQ3.png]: https://i.imgur.com/6CtMAQ3.png
[KAuNwaQ.png]: https://i.imgur.com/KAuNwaQ.png