【Java集合】Map接口常用方法及实现子类

Map为双列集合，Set集合的底层也是Map，只不过有一列是常量所占，只使用到了一列。

01 Map 接口实现类的特点

1. Map 与 Collection 并列存在，用于保存具有映射关系的数据：Key - Value；
2. Map 中的 Key 和 Value 可以是任何引用类型的数据，会封装到 HashMap$Node对象中；
3. Map中的 Key 不允许重复，原因和 HashSet 一样;
4. Map 中的 Value 可以重复；
5. Map 的 Key 可以为 null，value 也可以为 null，但 key 为 null 只能有一个；
6. 常用 String 类作为 Map 的 key，当然，其他类型也可以，但不常用；
7. Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到对应的 Value；

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

public class Map_ {
    //分析Map接口实现类的特点
    public static void main(String[] args){
        //1. Map 与 Collection 并列存在，用于保存具有映射关系的数据：Key - Value；
        Map map = new HashMap();
        map.put("No.1","我");//Key-Value
        map.put("No.2","你");// K-V
        map.put("No.3","他");// K-V
        System.out.println(map);//{No.2=你, No.1=我, No.3=他}
        //2. Map 中的 Key 和 Value 可以是任何引用类型的数据，会封装到 HashMap$Node对象中
        //3. Map中的 Key 不允许重复，原因和HashSet一样
        //4.Map 中的 Value 可以重复
        map.put("No.2","X"); //替换机制
        map.put("No.4","他");
        System.out.println(map);//{No.2=X, No.1=我, No.4=他, No.3=他}
        //5. Map 的 Key 可以为 null，value 也可以为 null，但 key 为 null 只能有一个；
        map.put("null","1");
        map.put("null","2");
        map.put("No.2","null");
        map.put("No.3","null");
        System.out.println(map);//{No.2=null, No.1=我, No.4=他, No.3=null, null=2}
        //6. 常用 String 类作为 Map 的 key，当然，其他类型也可以，但不常用；
        //7. Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到对应的 Value；
        //通过get方法，传入key，会返回对应的value
        System.out.println(map.get("No.1"));//我
    }
}

8. Map 存放数据的 key - value 示意图，一对 k - v 是放在一个 HashMap$Node 中的，又因为 Node 实现了 Entry 接口，所以也可以说，一对 k - v 就是一个 Entry ；

02 Map 接口和常用方法

• put ：添加
• remove ： 根据键删除映射关系
• get ： 根据键获取值
• size ： 获取元素个数
• isEmpty ： 判断个数是否为0
• clear ： 清除
• containsKey ： 查找键是否存在

import java.util.HashMap;
import java.util.Map;
    //演示 Map 接口常用方法
public class MapMethod {
    public static void main(String[] args) {
        Map map = new HashMap();
        //put方法：添加元素
        map.put("海绵宝宝","章鱼哥");
        map.put("海绵宝宝","派大星");
        map.put("熊大","熊二");
        map.put("大头儿子","小头爸爸");
        map.put("黑猫警长",null);
        map.put(null,"奥特曼");
        System.out.println(map);//{黑猫警长=null, null=奥特曼, 大头儿子=小头爸爸, 熊大=熊二, 海绵宝宝=派大星}
        //remove方法：根据键删除映射关系
        map.remove(null);
        System.out.println(map);//{黑猫警长=null, 大头儿子=小头爸爸, 熊大=熊二, 海绵宝宝=派大星}
        //get方法：根据键获取
        System.out.println(map.get("海绵宝宝"));//派大星
        //size方法：获取元素个数
        System.out.println(map.size());//4
        //isEmpty方法：判断个数是否为0
        System.out.println(map.isEmpty());//false
        //containsKey方法：查找键是否存在
        System.out.println(map.containsKey("黑猫警长"));//true
        //clear方法：清空
        map.clear();
        System.out.println(map);//{}
    }
}

03 Map 接口遍历方法

• containsKey ： 查找键是否存在
• keySet ： 获取所有的键
• entrySet ：获取所有关系
• values ： 获取所有的值

import java.util.*;

public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("海绵宝宝","派大星");
        map.put("熊大","熊二");
        map.put("大头儿子","小头爸爸");
        map.put("黑猫警长",null);
        map.put(null,"奥特曼");
        //第一种：先取出所有的Key，通过Key取出对应的value
        Set keySet = map.keySet();
        //(1)增强for
        for(Object key : keySet){
            System.out.println(key+" - "+map.get(key));
        }
        //(2)迭代器
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key+" - "+map.get(key));
        }

        //第二种：把所有的value取出
        Collection values = map.values();
        //然后遍历Collection就行
        //(1)增强for
        for(Object value : values){
            System.out.println(value);
        }
        //(2)迭代器
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object value =  iterator1.next();
            System.out.println(value);
        }

        //第三种：通过EntrySet来获取
        Set entrySet = map.entrySet();
        //(1)增强for
        for(Object entry : entrySet){
            //将entry转成map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey()+" - "+m.getValue());
        }
        //(2)迭代器
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()) {
            Object next = iterator2.next();
            //向下转型 Map.Entry
            Map.Entry m  =  (Map.Entry) next;
            System.out.println(m.getKey()+" - "+m.getValue());
        }
    }
}

04 HashMap 用例 小结

使用 HashMap 添加3个员工对象，要求：
键：员工id
值：员工对象
并遍历显示工资 > 18000的员工
（员工类：姓名，工资，员工id）

import java.util.*;

public class MapExercise {
    public static void main(String[] args) {
        //创建、添加
        HashMap hashMap = new HashMap();
        hashMap.put(1,new Emp("Jack",30000,1));
        hashMap.put(2,new Emp("Tom",20000,2));
        hashMap.put(3,new Emp("Milan",12000,3));
        //遍历一：使用keySet -> 增强for
        Set keySet = hashMap.keySet();
        for(Object key : keySet){
            //先获取value
            Emp emp = (Emp) hashMap.get(key);
            //薪水大于18000就打印
            if(emp.getSal() > 18000){
                System.out.println(emp);
            }
        }
        //遍历二：使用EntrySet -> 迭代器
        Set entrySet = hashMap.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry entry =  (Map.Entry)iterator.next();
            //通过entry取得key和value
            Emp emp = (Emp) entry.getValue();
            if(emp.getSal() > 18000){
                System.out.println(emp);
            }
        }
    }
}
class  Emp{
    private String name;
    private double sal;
    private int id;

    public Emp(String name, double sal, int 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 int getId() {
        return id;
    }

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

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", id=" + id +
                '}';
    }
}

1. Map 接口的常用实现类：HashMap、Hashtable、Properties;
2. HashMap 是 Map 接口使用频率最高的实现类；
3. HashMap 是以 key - value 对的形式来存储的；
4. key 不能重复添加，但value可以，都允许使用null；
5. 如果添加相同的 key，则会覆盖原来的 key - value，等同于修改；
6. 与 HashSet一样，不保证映射的顺序，因为底层是以hashbiao的方式来存储的；
7. HashMap 没有实现同步，所以线程不安全；

05 HashMap 底层&扩容机制

1. HashMap 底层维护了 Node 类型的数组 table ，默认为 null；
2. 当创建对象时，将加载因子（loadfactor）初始化为0.75；
3. 当添加 key-value 时，通过 key 的哈希值得到在 table的索引，然后判断该索引处是否有元素，如果没有元素则直接添加。如果该索引处有元素，继续判断该元素的 key 是否和准备加入的 key 相等，如果相等，则直接替换 value；如果不相等，则需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。（扩容机制和HashSet完全一样，因为HashSet底层就是HashMap）
4. 第一次添加，会扩容 table 容量为16，临界值（threshold）为12；
5. 以后再扩容，会扩容 table 容量为原来的2倍，临界值为原来的2倍，即24，以此类推；
6. 在Java8中，如果一条链表的元素个数超过 TREEIFY_THRESHOLD（默认是8），并且 table的大小>= MIN_CAPACITY（默认是64），就会进行树化（红黑树）；

---

06 Hashtable

Hashtable的基本介绍：

1. 存放的元素都是键值对，即 key - value；
2. Hashtable 的键和值都不能为 null，否则会抛出NullPointerException
3. Hashtable 使用方法基本上和 HashMap 一样；
4. Hashtable 是线程安全的（synchronized）， HashMap是线程不安全的；

Hashtabel table =  new Hashtable();
table.put("John",100);//OK
table.put(null,100);//异常 NullPointerException
table.put("",null);//异常
table.put("John",128);//替换

Hashtable的底层原理：
1.底层有数组 Hashtables$Entry[] 初始化大小为1；
2.临界值 threshold 8 = 11 * 0.75；
3.扩容机制：执行方法 addEntry(hash,key,value,index);添加 K-V，封装到Entry；
4.当 if(count >= threshold) 满足就扩容；
5.按照 int newCapacity = (oldCapacity << 1)+1; 扩容

对比	线程安全（同步）	效率	允许 null 键 null 值
HashMap	不安全	高	可以
Hashtable	安全	较低	不可以

---

07 TreeMap

TreeMap 构造器可以传入比较器，所以TreeMap常用来排序，可以自定义存放数据顺序。

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMap_ {
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap();//默认构造器，默认比较：自然排序
        treeMap.put("Jack","杰克");
        treeMap.put("Tom","汤姆");
        treeMap.put("Smith","史密斯");
        System.out.println(treeMap);//{Jack=杰克, Smith=史密斯, Tom=汤姆}由小到大排序

        //如果按照传入的key由大到小排序：
        treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o2).compareTo((String)o1);
                //如果是按照长度由大到小：return ((String)o1).length()-((String)o2).length(); 
            }
        });
        treeMap.put("Jack","杰克");
        treeMap.put("Tom","汤姆");
        treeMap.put("Smith","史密斯");
        System.out.println(treeMap);//{Tom=汤姆, Smith=史密斯, Jack=杰克} 由大到小排序
    }
}

---

08 Properties

1. Properties 类继承自 Hashtable 类并且实现了Map接口，也是使用一种键值对的形式来保存数据；
2. 使用特点和 Hashtable 相似；
3. Properties 还可以用于从 xxx.properties 文件中，加载数据到Properties类对象，并进行读取和修改；
4. 说明：xxx.properties 文件通常作为配置文件，这在 IO流 也有讲解

Properties博客介绍