Java之Map双列集合（HashMap和LinkedMap）,Map集合的两种遍历方式，自定义类型对象作为键添加的注意事项，HashTable集合的相关了解

目录

Map集合

Map常用子类

Map接口中的常用方法

Map集合遍历方式（2种）

HashMap集合（或者其他Map集合）存储自定义类型键值（重写hashCode和equals方法）

LinkedHashMap集合

HashTable集合

---

Map集合

java.util.Map<K,V>集合，其中泛型K和V分别表示键和值。

Map集合的特点：

1.Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）。

2.Map集合中的元素，key和value的数值类型可以相同也可以不同。

3.Map集合中的元素，key是不允许重复的，value可以重复。

4.Map集合中的元素，key和value是一一对应的。

Map常用子类

Map有多个子类，常用的是HashMap集合、LinkedHashMap集合。

1. java.util.HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

2. java.util.LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

 上述的两个集合与单列集合中的HashSet和LinkedHashSet类似(特点是一样的)。

Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  对于返回值，如果key不重复，返回值是null；如果key重复，会使用新的value替代马匹中重复的value，并且返回被替代的value值。在常用情况下，返回值无需接收，很少使用它的返回值。

• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值，如果key不存在则返回空(null)。

• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。

• boolean containsKey(Object key) 判断集合中是否包含指定的键。包含返回true，不包含返回false。

• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
  把Map集合中所有的key取出来存储到set集合中作为返回值。

• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
  备注：当Map集合一创建，就会在Map集合中自动创建一个Entry对象（即Map.Entry<K,V>），用来记录键与值的映射关系。
  作用：该方法把Map集合内部的多个Entry对象取出来，存储到一个Set集合中。

Map集合遍历方式（2种）

1.键找值的方式：即通过元素中的键，获取键对应的值。

步骤：

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。使用keySet()方法。
2. 遍历键的Set集合，得到每一个键。使用增强for结构。
3. 根据键，获取键所对应的值。使用get(K key)方法。

public class MapDemo01 {
    public static void main(String[] args) {
        //创建Map集合对象 
        HashMap<String, String> map = new HashMap<String,String>();
        //添加元素到集合 
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");

        //获取所有的键  获取键集
        Set<String> keys = map.keySet();
        // 遍历键集 得到 每一个键
/*
        使用迭代器
        Iterator<String> it = keys.iterator();
        while(it.hasNext){
            String key = it.next();
            String value = map.get(key);
            System.out.println(key+"="+value);
        }
*/
        for (String key : keys) {
          	//key  就是键
            //获取对应值
            String value = map.get(key);
            System.out.println(key+"的CP是："+value);
        }  
    }
}

遍历图解：从右往左。

2. 使用Entry对象来遍历

Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

• public K getKey()：获取Entry对象中的键。

• public V getValue()：获取Entry对象中的值。

步骤：

1. 获取所有Entry对象。使用entrySet()方法
2. 对每一个Entry对象获取具体的键和值。使用getKey()和getValue()方法。

public class MapDemo01 {
    public static void main(String[] args) {
        //创建Map集合对象 
        HashMap<String, String> map = new HashMap<String,String>();
        //添加元素到集合 
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");                             

        //获取所用的Entry对象，获取Entry集合
        Set<Map.Entry<String,String>> entrys = map.entrySet();
        // 遍历Entry对象， 得到每一个键和值
/*
        使用迭代器
        Iterator<Map.Entry<String,String>> it = entrys.iterator();
        while(it.hasNext){
            Map.Entry<String,String> entry = it.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
*/
        for (Map.Entry<String,String> entry : entrys) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }  
    }
} 

HashMap集合（或者其他Map集合）存储自定义类型键值（重写hashCode和equals方法）

当给HashMap集合（或者是其他Map集合）中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须重写对象的hashCode和equals方法(类似HashSet如果要存放自定义对象，也需要重写)。

备注：String类已经重写了hashCode和equals方法，如果使用String类型作为key，默认已经保证了key是唯一的。

// 定义一个自定义类型的对象，并且重写了equals方法和hashCode方法
import java.util.Objects;
public class Person {
    private String name;
    private int age;
    @Override // 重写toString方法，因为要显示对象的内容而不是地址值
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override  /* 重写equals方法和hashCode方法，是为了让对象的内容来区分是否是一个对象
（实际生活中的比较），而不是对象地址来区分是否是同一个对象（对象实现原理的默认比较）。*/
    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);
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
// 自定义类型在Map集合中的使用
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapKV {
    public static void main(String[] args) {
        show01();
        System.out.println("=============================");
        show02();
    }
    /*HashMap存储自定义类型作为值
        key：String类型。因为String类重写了hashCode方法和equals方法，可以保证key唯一。
        value：Person类型。value可以重复，所以无需重写这两个方法。
    */
    private static void show01() {
        HashMap<String, Person> map = new HashMap<>();
        map.put("沉鱼",new Person("西施",19));
        map.put("落雁",new Person("王昭君",21));
        map.put("闭月",new Person("貂蝉",18));
        map.put("羞花",new Person("杨玉环",20));
        map.put("羞花",new Person("迪丽热巴",20)); // 此时key是相同的，当前值会替换之前的value。
        map.put("花旦",new Person("迪丽热巴",20)); // 此时value是相同的，但是key不同。直接添加进去。
        System.out.println(map);
        // 输出：{落雁=Person{name='王昭君', age=21}, 花旦=Person{name='迪丽热巴', age=20}, 闭月=Person{name='貂蝉', age=18}, 羞花=Person{name='迪丽热巴', age=20}, 沉鱼=Person{name='西施', age=19}}
        // keySet遍历
        Set<String> set = map.keySet();
        for (String key : set) {
            System.out.println(key+"="+map.get(key));
        }
    }

    /*HashMap存储自定义类型作为键
        key：Person类型。key不允许重复，所以一定要重写hashCode和equals方法，来保证唯一性。
        value：String类型。value值可以重复。
    */
    private static void show02() {
        HashMap<Person, String> map = new HashMap<>();
        map.put(new Person("西施",19),"沉鱼");
        map.put(new Person("王昭君",21),"落雁");
        map.put(new Person("貂蝉",18),"闭月");
        map.put(new Person("杨玉环",20),"羞花");
        map.put(new Person("迪丽热巴",20),"羞花"); // 此时value是相同的，但是key不同。直接添加进去。
        map.put(new Person("迪丽热巴",20),"花旦"); // 此时key是相同的，Person对象原始的区
        // 分只是地址值，但是要以内容为区分就得要重写hashCode和equals方法，
        // 这样才能保证这两个对象是唯一的。
        System.out.println(map);
        // 输出：{Person{name='王昭君', age=21}=落雁, Person{name='貂蝉', age=18}=闭月, Person{name='西施', age=19}=沉鱼, Person{name='杨玉环', age=20}=羞花, Person{name='迪丽热巴', age=20}=花旦}
        // entrySet遍历
        Set<Map.Entry<Person, String>> entries = map.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
    }
}

LinkedHashMap集合

如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

java.util.LinkedHashMap<K, V>  extends  HashMap<K, V>

底层结构原理：哈希表+链表（记录元素的顺序）

HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，如果要保证有序，还要速度快，那么使用LinkedHashMap集合。

HashTable集合

java.util.HashTable<K, V> 集合 implements Map<K, V>接口

和HashMap集合的对比：

1.底层。HashTable底层：哈希表，是一个线程安全的集合，是单线程集合，速度慢。

               HashMap底层：哈希表，是一个线程不安全的集合，是多线程的集合，速度快。

2. null值。HashTable集合：不能存储null键，null值。

                 HashMap集合（所有的Set集合和其他的Map集合）：可以存储null键值。

HashTable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap和ArrayList）取代了。但是，HashTable的子类Properties依然活跃在历史舞台。

Properties集合是一个唯一和IO流相结合的集合！