Java语言之Map集合

一，概述

java.util.Map(K,V)集合。
Map集合特点：
1，Map集合是一个双列集合，一个元素包含两个值（一个key,一个value）；
2，Map集合中的元素，key和value的数据类型可以一致，也可以不同；
3，Map集合中的元素，key是不允许重复的，value是可以重复的；
4，Map集合中的元素，key和value是一一对应的。

二，HashMap集合

java.util.HashMap<K,V>集合 implements Map<K ,V>接口。
HashMap集合特点：
1，HashMap集合底层是哈希表：查询速度特别快。
JDK1.8之前：数组+单向链表；
JDK1.8之后：数组+单向链表/红黑树（链表长度超过8时）。
2，HashMap是一个无序集合，存储元素和取出元素顺序可能不一致。

三，LinkedHashMap集合

java.util.LinkedHashMap<K,V>集合 extends HashMap<K,V>集合。
LinkedHashMap特点：
1，LinkedHashMap底层是哈希表+链表（保证迭代顺序）；
2，LinkedHashMap集合是一个有序集合，存储元素和取出元素顺序一致。

四，Map接口中常用方法

V put(K key,V value):把指定的键和指定的值添加到Map集合当中。
返回值：V
1,存储键值对时，key不重复，返回值V是null;
2,存储键值对时，key重复,会使用新的value替换map中重复的value,返回被替换的值。

V remove(Object key):把指定的键值对元素从map集合当中删除，返回被删除元素的值。
返回值：V
1，key存在，V返回被删除元素的值；
2，key不存在，返回null。

V get(Object key):根据指定的键，返回集合中对应的值。
返回值：V
1，key存在，返回value值；
2，key不存在，返回null；

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

import java.util.HashMap;

public class DemoHashMap {
    public static void main(String[] args) {
        demo1();
        demo2();
        demo3();
        demo4();

    }

    private static void demo4() {
        HashMap<String, Integer> map4 = new HashMap<>();
        map4.put("小海",171);
        map4.put("小军",175);
        map4.put("小鸿",171);
        boolean b1 = map4.containsKey("小红");
        System.out.println(b1); //false
        boolean b2 = map4.containsKey("小军");
        System.out.println(b2); //true
    }

    private static void demo3() {
        HashMap<String, Integer> map3 = new HashMap<>();
        map3.put("小海",171);
        map3.put("小军",175);
        map3.put("小鸿",171);
        Integer v2 = map3.get("小鸿");
        System.out.println(v2); //171
        Integer v3 = map3.get("小美");
        System.out.println(v3); //null
    }

    private static void demo2() {
        HashMap<String, Integer> map2 = new HashMap<>();
        map2.put("小海",171);
        map2.put("小军",175);
        map2.put("小鸿",171);
        System.out.println(map2); //{小海=171, 小军=175, 小鸿=171}
        Integer v1 = map2.remove("小军");
        System.out.println(v1); //175
        Integer v2 = map2.remove("小美");
        System.out.println(v2); //null

    }

    private static void demo1() {
        HashMap<String, String> map = new HashMap<>();
        String s1 = map.put("火箭", "哈登");
        System.out.println(s1); //null
        String s2 = map.put("湖人", "戴维斯");
        System.out.println(s2);//null
        String s3 = map.put("湖人", "詹姆斯");
        System.out.println(s3); //戴维斯
        System.out.println(map); //{湖人=詹姆斯, 火箭=哈登}
    }
}

五，Map集合遍历方式

1，通过键找值的方式
方法：set keySet():返回映射中包含键的set视图。
实现步骤：
（1），使用Map集合中的方法keySet(),把map集合中所有的key取出，存储到一个set集合当中；
（2），遍历set集合，获取map集合中每一个key;
（3），通过map集合中的方法get(key),通过key找value。

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

public class DemoKeySet {
    public static void main(String[] args) {
        demo1();
    }

    private static void demo1() {
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",163);
        map.put("杨幂",165);
        map.put("迪丽热巴",168);

        Set<String> set1 = map.keySet();
        Iterator<String> it = set1.iterator();
        while(it.hasNext()){
            String key = it.next();
            Integer value = map.get(key);
            System.out.print(key+"="+value+" "); //赵丽颖=163 迪丽热巴=168 杨幂=165
        }

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.print(key+"="+value+" "); //赵丽颖=163 迪丽热巴=168 杨幂=165
        }
    }
}

2，Map.Entry<K,V>:在Map接口当中有一个内部接口Entry,作用是当Map集合一创建，那么就会在Map集合当中创建一个Entry对象，用来记录键和值（键值对对象键和值的映射关系）。
方法：Set<Map.Entry<K,V>> entrySet():返回此映射中包含的映射关系的Set视图。
实现步骤：
（1），使用Map集合当中的方法entrySet（），把Map集合当中多个entry对象取出来，存储到一个Set集合当中。
（2），遍历Set集合，取出每一个entry对象；
（3），使用entry对象中的方法getKey()和getValue()获取键和值。

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

public class DemoEntrySet {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",163);
        map.put("杨幂",165);
        map.put("迪丽热巴",168);

        Set<Map.Entry<String, Integer>> set = map.entrySet();
        for (Map.Entry<String, Integer> setobj : set) {
            String key = setobj.getKey();
            Integer value = setobj.getValue();
            System.out.print(key+"="+value+" "); //赵丽颖=163 迪丽热巴=168 杨幂=165
        }

        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()){
            Map.Entry<String, Integer> obj = it.next();
            String key = obj.getKey();
            Integer value = obj.getValue();
            System.out.print(key+"="+value+" ");//赵丽颖=163 迪丽热巴=168 杨幂=165
        }
    }
}

六，HashMap存储自定义类型

Map集合须保证key是唯一的：
作为key元素，必须重写hashCode()方法和equals方法，以保证key唯一。
存储自定义类型：
1，key:String类，已经重写了hashCode()方法和equals()方法，可以保证key的唯一性。
value:Person类型，value可重复（同名同年龄视为同一个）。
2，key:Person类，须自己重写hashCode()方法和equals()方法，以保证key唯一。
values:String类，可以重复。

import java.util.Objects;

public class Person {
    private String name;
    private int age;

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

    @Override
    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 class DemoHashMapSavePerson {
    public static void main(String[] args) {
        demo1();
        demo2();
    }

    private static void demo2() {
        HashMap<Person,String> map = new HashMap<>();
        map.put(new Person("小虎",18),"广东");
        map.put(new Person("小浩",20),"福建");
        map.put(new Person("小谷",19),"广西");
        map.put(new Person("小虎",18),"湖南");
        Set<Map.Entry<Person, String>> set = map.entrySet();
        Iterator<Map.Entry<Person, String>> it = set.iterator();
        while(it.hasNext()){
            Map.Entry<Person, String> entry = it.next();
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+":"+value);
            /*未重写hashCode()和equals()方法之前：
            Person{name='小虎', age=18}:湖南
            Person{name='小浩', age=20}:福建
            Person{name='小虎', age=18}:广东
            Person{name='小谷', age=19}:广西
            之后：
            Person{name='小谷', age=19}:广西
            Person{name='小虎', age=18}:湖南
            Person{name='小浩', age=20}:福建
            */
        }
    }

    private static void demo1() {
        HashMap<String,Person> map = new HashMap<>();
        map.put("广东",new Person("小虎",18));
        map.put("福建",new Person("小浩",20));
        map.put("广西",new Person("小谷",19));
        map.put("广东",new Person("小寻",15));
        Set<String> keys = map.keySet();
        for (String key : keys) {
            Person value = map.get(key);
            System.out.println(key+"-->"+value);
        }
        /*
        福建-->Person{name='小浩', age=20}
        广东-->Person{name='小寻', age=15}
        广西-->Person{name='小谷', age=19}
        */
    }
}