一，概述
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}
*/
}
}
