Java学习笔记 --- Map接口方法

一、Map接口实现类的特点

1、Map 与 Collection 并列存在。用于保存具有映射关系的数据：Ket - Value

2、Map 中的 key 和 value 可以是任何引用类型的数据，会封装到 HashMap$Node 对象中

3、Map 中的 key 不允许重复，原因和 HashSet 一样

4、Map 中的 value 可以重复

5、Map 的 key 可以为 null，value 也可以为 null，注意 key 为 null，只能有一个，value 为 null，

      可以多个

6、常用 String 类作为 Map 的 key

7、key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value

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

public class Map01 {
    public static void main(String[] args) {
        //Map 与 Collection 并列存在。用于保存具有映射关系的数据：Ket - Value
        Map map = new HashMap();
        map.put("n1", "张三");//k-v
        map.put("n2", "李四");//k-v

        //Map 中的 key 不允许重复，原因和 HashSet 一样
        map.put("n1", "老六");//当有相同的 key 时，等价于替换

        //Map 中的 value 可以重复
        map.put("n3", "老六");//k-v

        //Map 的 key 可以为 null，value 也可以为 null，
        //注意 key 为 null，只能有一个，value 为 null，可以多个
        map.put(null, null);//k-v
        map.put(null, "abc");//当有相同的 key 时，等价于替换
        map.put("n4", null);//k-v

        //常用 String 类作为 Map 的 key，其他类型也可以
        map.put(1, "老六");//k-v
        map.put(new Object(), "老六");//k-v

        //key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value
        //通过get方法，传入key，返回对应的value
        System.out.println(map.get(1));//老六

        System.out.println(map);
    }
}

8、Map 存放数据的 key-value 示意图，一对 k-v 是放在一个 Node 中的，又因为 Node 实现了       Entry 接口，有些书上也说，一对 k-v 就是一个 Entry

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

public class MapSource {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("n1", "张三");//k-v
        map.put("n2", "李四");//k-v

        //源码解读
        //1. k-v 最后是 HashMap$Node node = newNode(hash, key, value, null)
        //2. k-v 为了方便程序员的遍历，还会创建 EntrySet 集合，该集合存放的元素类型 Entry，
        //   而一个 Entry 对象就有k，v EntrySet<Entry<K, V>> 即：transient Set<Map.Entry<K, V>> entrySet
        //3. entrySet 中，定义类型是 Map.Entry，但是实际上存放的还是 HashMap$Node
        //   这是因为 static class Node<K, V> implements Map.Entry<K, V>
        //4. 当把 HashMap$Node 对象存放到 entrySet 就方便我们的遍历，因为 Map.Entry 提供了重要方法
        //   K getKey();   V getValue();

        Set set = map.entrySet();
        System.out.println(set.getClass());//HashMap$EntrySet
        for (Object o : set) {
            //为了从 HashMap$Node 中取出 k-v
            //1. 先做一个向下转型
            Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

        Set set1 = map.keySet();
        System.out.println(set1);//[n1, n2]

        Collection values = map.values();
        System.out.println(values);//[张三, 李四]
    }
}

二、Map体系继承图

三、Map接口常用方法

1、put：添加

2、remove：根据键删除映射关系

3、get：根据键获取值

4、size：获取元素个数

5、isEmpty：判断个数是否为0

6、clear：清空

7、containsKey：查找键是否存在

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

public class MapMethod {
    public static void main(String[] args) {
        Map map = new HashMap();

        //1、put：添加
        map.put("张三", "20");//OK
        map.put("张三", "哈哈");//替换
        map.put("李四", "999");//OK
        map.put("n1", "老六");//OK
        map.put("雅马哈", "MT-03");//OK
        map.put("n2", null);//OK
        map.put(null, null);//OK

        System.out.println(map);

        //2、remove：根据键删除映射关系
        map.remove(null);
        System.out.println(map);

        //3、get：根据键获取值
        Object value = map.get("雅马哈");
        System.out.println(value);//MT-03

        //4、size：获取元素个数
        System.out.println(map.size());//5

        //5、isEmpty：判断个数是否为0
        System.out.println(map.isEmpty());//false

        //6、clear：清空
        map.clear();
        System.out.println(map);//{}

        //7、containsKey：查找键是否存在
        System.out.println(map.containsKey(null));//false
    }
}

四、Map接口遍历方法

1、containsKey：查找键是否存在

2、keySet：获取所有键

3、entrySet：获取所有的关系

4、values：获取所有值

import java.util.*;

public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("张三", "哈哈");
        map.put("李四", "999");
        map.put("n1", "老六");
        map.put("雅马哈", "MT-03");

        //第一组：先取出所有 key，通过key取出对应的value
        Set set = map.keySet();
        //增强for
        System.out.println("======第一种方式======");
        for (Object key : set) {
            System.out.println(key + "-" + map.get(key));
        }
        //迭代器
        System.out.println("\n======第二种方式======");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key + "-" + map.get(key));
        }

        //第二组：把所有的value取出.
        Collection values = map.values();
        //增强for
        System.out.println("\n======取出所有的value 增强for======");
        for (Object value : values) {
            System.out.println(value);
        }
        //迭代器
        System.out.println("\n======取出所有的value 迭代器======");
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object value =  iterator1.next();
            System.out.println(value);
        }

        //第三组：通过 entrySet 来获取 k-v
        Set set1 = map.entrySet();
        //增强for
        System.out.println("\n======使用entrySet 增强for======");
        for (Object obj : set1) {
            //向下转型 Map.Entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
        //迭代器
        System.out.println("\n======使用entrySet 迭代器======");
        Iterator iterator2 = set1.iterator();
        while (iterator2.hasNext()) {
            Object next =  iterator2.next();//HashMap$Node
            Map.Entry entry = (Map.Entry) next;//向下转型 Map.Entry
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
    }
}

五、入门练习

使用HashMap添加3个员工，要求：

键：员工id 

值：员工对象

并遍历显示工资>18000的员工(遍历方式最少两种) 

员工类：姓名 工资 员工id

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

/**
 * 使用HashMap添加3个员工，要求：
 * 键：员工id
 * 值：员工对象
 * 并遍历显示工资>18000的员工(遍历方式最少两种)
 * 员工类：姓名 工资 员工id
 */
public class MapExercise {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(10010, new Employees("张三", 20000, "10010"));
        map.put(10011, new Employees("李四", 15000, "10011"));
        map.put(10012, new Employees("老六", 66666, "10012"));

        //第一种遍历
        System.out.println("====使用keySet 增强for====");
        Set set = map.keySet();
        for (Object key : set) {
            Employees employees = (Employees) map.get(key);
            if (employees.getSal() > 18000) {
                System.out.println("ID=" + key  + " 员工信息=" + map.get(key));
            }
        }

        //第二种遍历
        System.out.println("\n====使用entrySet 增强for====");
        Set set1 = map.entrySet();
        for (Object obj : set1) {
            //向下转型 Map.Entry
            Map.Entry entry = (Map.Entry) obj;
            Employees employees = (Employees) entry.getValue();
            if (employees.getSal() > 18000) {
                System.out.println("ID=" + entry.getKey()  + " 员工信息=" + entry.getValue());
            }
        }
    }
}

class Employees {
    private String name;
    private double sal;
    private String id;

    public Employees(String name, double sal, String id) {
        this.name = name;
        this.sal = sal;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "姓名：" + name + " 工资：" + sal + " ID：" + id;
    }
}