Java Map 接口详解

软件包：java.util
接口：Map
描述：将键映射到值的对象

一，Map与Collection

1. Collection接口：定义了单列集合规范，集合中的元素是独立存在的，每次存储一个（单个）元素
2. Map接口：定义了双列集合的规范，集合中的元素是成对出现的，每次存储一对元素，每个元素由键和值两部分组成，通过键可以找到对的值

二，Map<K,V>接口

1. 映射：像IP地址与主机名这种一一对应的关系就叫做映射，Map接口提供了专门的集合类来存放这种映射关系的对象

2. 类型参数：元素是一个键值对

   K（key） - 此映射所维护的键的类型（键）

   V（value） - 映射值的类型（值）

   一个映射不能包含重复的键，但值可以重复

3. 特点

   • Map是一个双列集合，其中每个元素包含键（key）和值（value）两个部分，两个部分一一对应
   • 键（key）和值（value）的数据类型可以相同也可以不同
   • 键（key）不允许重复，值（value）可以重复

三，实现类

1. HashMap<K,V>：基于哈希表的Map接口的实现，不同步（多线程），是一个无序的集合
   • 特点：查询速度快，key不允许重复，无序
2. LinkedHashMap<K,V>：HashMap的子类，基于哈希表和链表的Map接口的实现，是一个有序的集合
   • 特点：查询速度快，key不允许重复，多了一层链表，保证了元素的有序（存和取的顺序一致）
3. HashTable<K,V>：早期的双列集合（JDK1.0+），基于哈希表的Map接口的实现，与HashMap类似，但不允许存储null对象，同步（单线程，线程安全，速度慢），与Vector集合一样在JDK1.2版本被取代

提示：哈希表 = 数组 + 链表/红黑树（提高了查询速度）

四，常用方法

方法	描述
put(K key,V value)	把指定的值与键添加到Map集合中，返回value值
remove（Object key）	把指定键所在的键值对在集合中删除，返回被删除元素
get（Object key）	根据指定的键，获取对应的值
containsSky（Object key）	判断集合是否包含指定键，返回true或false
keySet()	获取Map集合中所有的键，存储到Set集合
entrySet()	获取Map集合中所有的键值对对象，存储到Set集合

注意：

• put()方法，若key不重复，返回值value返回null；若key重复，会使用新的value替换Map中重复的value，返回被替换的value
• remove（）方法，若key存在，删除对应的键值对，返回被删除的value；若key不存在，返回值value返回null
• get（）方法，若key存在，返回对应的值；若key不存在，返回null

五，使用

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

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        /* put(K key,V value) */
        String s1 = map.put("张三","1");  //Map中原来没有此key，value返回null
        System.out.println(s1); //null

        String s2 = map.put("张三","2");  //Map中已有此key，value被替换，并返回原来的值"1"
        System.out.println(s1); //1

        map.put("李四","1");
        System.out.println(map); //{李四=1, 张三=2}（打印的不是地址，Map重写了toString方法）

        System.out.println("------");

        /* remove（Object key） */
        System.out.println(map);
        String s3 = map.remove("张三");  //返回对应的value值
        System.out.println(s3);// 2
        System.out.println(map);

        String s4 = map.remove("1");  //没有此元素，返回null
        System.out.println(s4);// null

        System.out.println("------");

        /* get（Object key） */
        System.out.println(map.get("李四")); //1
        System.out.println(map.get("1")); //null
    }
}

注意：获取返回的value值时，为防止元素不存在返回null时出现异常，多使用包装类

六，Entry键值对对象

1. Map.Entry<K,V>：在Map接口中有一个内部接口Entry
2. 概念：一对键值对在Map中被称为一个Entry（项），Entry将键值对的对应关系封装成了对象，即键值对对象，当Map集合创建时，就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象，键与值的映射关系）
3. 使用：
   • entrySet（）：把Map集合内部的多个Entry对象取出来，存储到一个Set集合
   • getKey（）：Entry对象中的方法，用于获取key
   • getvalue（）：Entry对象中的方法，用于获取value

七，遍历

1. 通过键找值

   • 使用keySet()方法获取Map集合中所有的键，存储到Set集合
   • 使用迭代器或增强for循环遍历，获取key
   • 通过key，使用get()方法获取对应的value

   Map<String,Integer> map2 = new HashMap<>();
   	map2.put("张三",18);
   	map2.put("李四",17);
   	Set<String> s = map2.keySet();  //使用keySet()方法获取Map集合中所有的键，存储到Set集合
   	for (String i : s) {  //使用迭代器或增强for循环遍历，获取key
   		System.out.println(i);
   		System.out.println(map2.get(i)); //通过key，使用get()方法获取对应的value
   	}
   	/* 也可以使用Iterator迭代器 */
   	Iterator<String> it = s.iterator();
           while (it.hasNext()){
               String key = it.next();
               System.out.println(key);
               System.out.println(map2.get(key));
           }
   

2. 通过Entry对象

   • 获取所有键值对的Entry对象
   • 通过Entry对象获取对象中的键与值

   Map<String,Integer> map3 = new HashMap<>();
   	map3.put("张三",18);
   	map3.put("李四",17);
   	Set<Map.Entry<String,Integer>> set = map3.entrySet(); //将Entry对象存储到set集合
   	for (Map.Entry<String, Integer> i : set) {  //获取每一个Entry对象 
   		System.out.println(i.getKey());  //通过Entry对象获取对象中的键与值
   		System.out.println(i.getValue());
   	}
   

八，HashMap存储自定义类型键值

Map集合保证key是唯一的：作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一

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

public class DemoHashMap {
    public static void main(String[] args) {
        show();
    }

    private static void show() {
        HashMap<Person,String> map = new HashMap<>();
        map.put(new Person("张三",18),"北京");
        map.put(new Person("李四",17),"北京");
        map.put(new Person("张三",18),"北京");
        Set<Map.Entry<Person, String>> smap = map.entrySet();
        for (Map.Entry<Person, String> i : smap) {
            System.out.println(i.getKey()+"->"+i.getValue());
        }
    }
}

import java.util.Objects;

public class Person {
    private String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}