Java类HashMap常用API详解

HashMap - 测试类

package HashMap_UtilityClass;

import HashMap_UtilityClass.domain.Person;

import java.util.*;

/**
 * HashMap测试类
 */
public class HashMapTest {

    public static void main(String[] args) throws CloneNotSupportedException {

        // 向一个映射中添加键值
        HashMap<String, String> eleMap = new HashMap<String, String>();
        eleMap.put("李荣浩", "安徽蚌埠");
        eleMap.put("杨丞琳", "台湾台北");
        eleMap.put("邢晗铭", "浙江温州");
        System.out.println("向一个映射中添加键值：");
        MapElementTraversal(eleMap);

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

        // 将A映射的所有键值放入B映射中，B映射中原有的键值仍然保留
        HashMap<String, String> newMap = new HashMap<String, String>();
        newMap.put("保留键1", "保留值1");
        newMap.put("保留键2", "保留值2");
        System.out.println("原映射中的键值：");
        MapElementTraversal(newMap);
        System.out.println("\n将A映射中的键值放入B映射中：");
        newMap.putAll(eleMap);
        MapElementTraversal(newMap);

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

        // 返回某映射中的所有键值关系数
        System.out.println("清除eleMap映射中所有映射关系前的映射数：" + eleMap.size());
        // 判断一个映射中是否存在映射关系，不存在则返回true
        IsEmptyOrNot(eleMap);

        // 清除某映射中的所有映射关系
        eleMap.clear();
        System.out.println("\n清除eleMap映射中所有映射关系后的映射数：" + eleMap.size());
        // 判断一个映射中是否存在映射关系，不存在则返回true
        IsEmptyOrNot(eleMap);

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

        // 返回指定键所映射的值
        System.out.println("返回指定键所映射的值：");
        System.out.println("键(李荣浩)映射的值(" + newMap.get("李荣浩") + ")");
        System.out.println("键(杨丞琳)映射的值(" + newMap.get("杨丞琳") + ")");

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

        // 判断当前映射中是否包含某个键
        System.out.println("当前映射中是否存在键(邢晗铭)：" + newMap.containsKey("邢晗铭"));
        System.out.println("当前映射中是否存在键(田颖)：" + newMap.containsKey("田颖"));
        // 判断当前映射中是否包含某个值
        System.out.println("\n当前映射中是否存在值(浙江温州)：" + newMap.containsValue("浙江温州"));
        System.out.println("当前映射中是否存在值(天津河东)：" + newMap.containsValue("天津河东"));

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

        // 从映射中移除指定且存在的某个键的映射关系
        System.out.println("获取并移除存在的键(保留键1)的映射关系：" + newMap.remove("保留键1"));
        System.out.println("获取并移除不存在的键(保留键3)的映射关系：" + newMap.remove("保留键3"));

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

        // 返回此映射中所包含的键的Set视图
        Set<String> mapKeys = newMap.keySet();
        System.out.println("使用Set集合接收当前映射中所有的键：");
        for (String items : mapKeys) {
            System.out.println(items);
        }

        // 返回此映射所包含的值的Collection视图
        Collection<String> mapValues = newMap.values();
        System.out.println("\n使用Collection集合接收当前映射中所有的值：");
        for (String items : mapValues) {
            System.out.println(items);
        }

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

        // 返回此映射中的所有映射关系的Set视图
        Set<Map.Entry<String, String>> entrySet = newMap.entrySet();
        System.out.println("返回此映射中的所有映射关系的Set视图：");
        for (Map.Entry<String, String> items : entrySet) {
            System.out.println(items);
        }

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

        // 回此映射实例的浅表副本，不复制键和值本身(浅克隆)
        HashMap<String, String> cpuType = new HashMap<String, String>();
        cpuType.put("Corei3", "i3-8350K");
        cpuType.put("Corei5", "i5-9600K");
        cpuType.put("Corei7", "i7-9800X");
        cpuType.put("Corei9", "i9-10940X");
        System.out.println("原映射中的映射关系：");
        MapElementTraversal(cpuType);

        HashMap<String, String> cloneType = new HashMap<String, String>();
        System.out.println("\n新映射中的映射关系(浅克隆)：");
        cloneType = (HashMap<String, String>) cpuType.clone();
        MapElementTraversal(cloneType);
        String corei9 = cpuType.get("Corei9");
        String cloneCorei9 = cloneType.get("Corei9");
        System.out.println("浅克隆：两个映射单实体指向相同的内存地址，corei9 == cloneCorei9的结果为：" + (corei9 == cloneCorei9));

        // 回此映射实例的深表副本，复制键和值本身(深克隆)
        Person p1 = new Person("李荣浩", '男', 35);
        Person p2 = new Person("邢晗铭", '女', 19);
        HashMap<String, Object> perMap = new HashMap<String, Object>();
        perMap.put("歌手1", p1);
        perMap.put("歌手2", p2);
        System.out.println("\n为映射元素深克隆准备单实体：");
        DeepCloneTraversal(perMap);

        Person person = MapElementDeepCloneDemo(p2);
        perMap.put("歌手3", person);
        System.out.println("\n映射元素单实体深克隆原理展示：");
        DeepCloneTraversal(perMap);
        System.out.println("深克隆：两个映射单实体指向不同的内存地址，p2 == person的结果为：" + (p2 == person));

        System.out.println();

    }

    /**
     * 映射元素深克隆原理演示
     *
     * @param person
     */
    private static Person MapElementDeepCloneDemo(Person person) {
        Person p = new Person(person.getName(), person.getGender(), person.getAge());
        p.setName("杨丞琳");
        p.setGender('女');
        p.setAge(36);
        return p;
    }

    /**
     * 深克隆元素遍历
     *
     * @param perMap
     */
    private static void DeepCloneTraversal(HashMap<String, Object> perMap) {
        String key = null;
        Object value = null;
        Iterator itor = perMap.entrySet().iterator();
        while (itor.hasNext()) {
            Map.Entry entry = (Map.Entry) itor.next();
            key = (String) entry.getKey();
            value = (Object) entry.getValue();
            System.out.println("键(" + key + ") - 值(" + value + ")");
        }
    }

    /**
     * 判断映射中是否存在映射关系
     *
     * @param map
     */
    private static void IsEmptyOrNot(HashMap<String, String> map) {
        // 判断一个映射中是否存在映射关系
        boolean flag = map.isEmpty();
        if (flag) {
            System.out.println("提示：当前映射为 [空] 映射！");
        } else {
            System.out.println("提示：当前映射为 [非空] 映射！");
        }
    }

    /**
     * 映射元素遍历
     *
     * @param map
     */
    private static void MapElementTraversal(HashMap<String, String> map) {
        String key = null, value = null;
        Iterator itor = map.entrySet().iterator();
        while (itor.hasNext()) {
            Map.Entry entry = (Map.Entry) itor.next();
            key = (String) entry.getKey();
            value = (String) entry.getValue();
            System.out.println("键(" + key + ") - 值(" + value + ")");
        }
    }

}

HashMap - 测试所需实体类

package HashMap_UtilityClass.domain;

/**
 * 深克隆原理演示所需的实体类
 */
public class Person implements Cloneable {

    private String name;
    private char gender;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

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

}

运行示范

向一个映射中添加键值：
键(李荣浩) - 值(安徽蚌埠)
键(杨丞琳) - 值(台湾台北)
键(邢晗铭) - 值(浙江温州)
--------------------------------------------------
原映射中的键值：
键(保留键1) - 值(保留值1)
键(保留键2) - 值(保留值2)

将A映射中的键值放入B映射中：
键(李荣浩) - 值(安徽蚌埠)
键(杨丞琳) - 值(台湾台北)
键(邢晗铭) - 值(浙江温州)
键(保留键1) - 值(保留值1)
键(保留键2) - 值(保留值2)
--------------------------------------------------
清除eleMap映射中所有映射关系前的映射数：3
提示：当前映射为 [非空] 映射！

清除eleMap映射中所有映射关系后的映射数：0
提示：当前映射为 [空] 映射！
--------------------------------------------------
返回指定键所映射的值：
键(李荣浩)映射的值(安徽蚌埠)
键(杨丞琳)映射的值(台湾台北)
--------------------------------------------------
当前映射中是否存在键(邢晗铭)：true
当前映射中是否存在键(田颖)：false

当前映射中是否存在值(浙江温州)：true
当前映射中是否存在值(天津河东)：false
--------------------------------------------------
获取并移除存在的键(保留键1)的映射关系：保留值1
获取并移除不存在的键(保留键3)的映射关系：null
--------------------------------------------------
使用Set集合接收当前映射中所有的键：
李荣浩
杨丞琳
邢晗铭
保留键2

使用Collection集合接收当前映射中所有的值：
安徽蚌埠
台湾台北
浙江温州
保留值2
--------------------------------------------------
返回此映射中的所有映射关系的Set视图：
李荣浩=安徽蚌埠
杨丞琳=台湾台北
邢晗铭=浙江温州
保留键2=保留值2
--------------------------------------------------
原映射中的映射关系：
键(Corei9) - 值(i9-10940X)
键(Corei7) - 值(i7-9800X)
键(Corei5) - 值(i5-9600K)
键(Corei3) - 值(i3-8350K)

新映射中的映射关系(浅克隆)：
键(Corei9) - 值(i9-10940X)
键(Corei7) - 值(i7-9800X)
键(Corei5) - 值(i5-9600K)
键(Corei3) - 值(i3-8350K)
浅克隆：两个映射单实体指向相同的内存地址，corei9 == cloneCorei9的结果为：true

为映射元素深克隆准备单实体：
键(歌手1) - 值(Person{name='李荣浩', gender=男, age=35})
键(歌手2) - 值(Person{name='邢晗铭', gender=女, age=19})

映射元素单实体深克隆原理展示：
键(歌手3) - 值(Person{name='杨丞琳', gender=女, age=36})
键(歌手1) - 值(Person{name='李荣浩', gender=男, age=35})
键(歌手2) - 值(Person{name='邢晗铭', gender=女, age=19})
深克隆：两个映射单实体指向不同的内存地址，p2 == person的结果为：false