Java集合——Map

Map集合

---

概述

---

• 现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等， 这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即 java.util.Map 接口。

• 我们通过查看 Map 接口描述，发现 Map 接口下的集合与 Collection 接口下的集合，它们存储数据的形式不同，如下图。

Map常用子类

---

Map接口中的常用方法

---

1. public V put(K key,V value)：把指定键与指定的值添加到Map集合中。
2. public V remove(Object key)：把指定的键所对应的键值对元素，在Map集合中删除，返回被删除元素的值。
3. public V get(Object key)：根据指定的键，在Map集合中获取对应的值。
4. public Set<K> KeySet()：获取Map集合中所有的键，存储到Set集合中。
5. public Set<Map.Entry<K,V>> entrySet()：获取Map集合中所有的键值对对象的集合（Set集合）。

• Map接口的方法演示：

import java.util.HashMap;  
import java.util.Iterator;  
import java.util.Map;  
import java.util.Set;  
  
public class Demo01 {  
    public static void main(String[] args) {  
        HashMap<String, String> hm = new HashMap<>();  
        //1.把指定键与指定的值添加到Map集合中  
        hm.put("白昼","庆尘");  
        hm.put("白昼","胡小牛");  
        hm.put("黑桃","秧秧");  
        hm.put("恒社","李东泽");  
  
        System.out.println(hm.size());  
  
        //2.把指定的键所对应的键值对元素，在Map集合中删除，返回被删除元素的值  
        String re = hm.remove("恒社");  
        System.out.println(re);  
        System.out.println(hm);  
  
        //3.根据指定的键，在Map集合中获取对应的值  
        String s = hm.get("黑桃");  
        System.out.println(s);  
  
        //4.获取Map集合中所有的键，存储到Set集合中  
        Set<String> keys = hm.keySet();  
        Iterator<String> it = keys.iterator();  
        while (it.hasNext()) {  
            String key = it.next();  
            System.out.println(key+","+hm.get(key));  
        }  
  
        //5.获取Map集合中所有的键值对对象的集合（Set集合）  
        Set<Map.Entry<String, String>> entries = hm.entrySet();  
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();  
        while (iterator.hasNext()) {  
            Map.Entry<String, String> entry = iterator.next();  
            System.out.println(entry.getKey());  
            System.out.println(entry.getValue());  
        }  
  
    }

• tips
  • 使用put方法时，若指定的键（key）在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中。
  • 若指定的键（key）在集合中存在，则返回值为集合中键的对应值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

Map集合遍历键找值方式

---

• 代码如下：

//通过map的key遍历map集合（迭代器方式）  
public static void getMap1(Map<String,String> map) {  
    Set<String> keys = map.keySet();  
    Iterator<String> it = keys.iterator();  
    while (it.hasNext()) {  
        String key = it.next();  
        System.out.println(key+","+map.get(key));  
    }  
}  
//通过map的key遍历map集合（增强for）  
public static void getMap2(Map<String,String> map) {  
    Set<String> keys = map.keySet();  
    for (String key:keys) {  
        System.out.println(key+"="+map.get(key));  
    }  
}

Entry键值对对象

---

Map集合遍历键值对方式

---

• 键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示: entrySet() 。

2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。

3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示: getkey() getValue()

public static void getMap3(Map<String,String> map) {  
    Set<Map.Entry<String, String>> entries = map.entrySet();  
    Iterator<Map.Entry<String, String>> iterator = entries.iterator();  
    while (iterator.hasNext()) {  
        Map.Entry<String, String> entry = iterator.next();  
        System.out.println(entry.getKey());  
        System.out.println(entry.getValue());  
    }  
}

HashMap存储自定义类型键值

---

• 练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到 map集合中。学生作为键, 家庭住址作为值。

• 注意，学生姓名相同并且年龄相同视为同一名学生。

• 编写学生类：

import java.util.Objects;  
  
public class Student {  
    private String name;  
    private int age;  
  
    public Student(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 boolean equals(Object o) {  
        if (this == o) return true;  
        if (o == null || getClass() != o.getClass()) return false;  
        Student student = (Student) o;  
        return age == student.age &&  
                Objects.equals(name, student.name);  
    }  
  
    @Override  
    public int hashCode() {  
        return Objects.hash(name, age);  
    }  
}

• 编写测试类：

import java.util.HashMap;  
import java.util.Map;  
import java.util.Set;  
  
public class StudentTest {  
    public static void main(String[] args) {  
        Map<Student,String> map = new HashMap<>();  
        map.put(new Student("景嘉伟",18),"上海");  
        map.put(new Student("周鹏",18),"北京");  
        map.put(new Student("宋柯",18),"北京");  
        map.put(new Student("王佳",18),"深圳");  
        System.out.println(map);  
  
        Set<Student> key = map.keySet();  
        for (Student stu:key) {  
            String value = map.get(stu);  
            System.out.println(value);  
            //System.out.println(key.toString());  
        }  
    }  
}

LinkedHashMap

---

• 我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那在HashMap下面有一个子类L么我们要保证有序，还要速度快怎么办呢？

• LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

import java.util.LinkedHashMap;  
import java.util.Map;  
import java.util.Set;  
  
public class Demo02 {  
    public static void main(String[] args) {  
        LinkedHashMap<String, String> map = new LinkedHashMap<>();  
        map.put("周鹏","18");  
        map.put("宋柯","19");  
        map.put("王佳","20");  
        map.put("嘉伟","20");  
  
        Set<Map.Entry<String, String>> entries = map.entrySet();  
        for (Map.Entry keys:entries) {  
            System.out.println(keys.getKey());  
            System.out.println(keys.getValue());  
        }  
    }  
}