Map集合及其子类理解
本文主要内容时Map集合和其子类HashMap与LinkedHashMap，包含格式以及一些特点和主要方法的使用，treeMap暂时没学到，没有对treeMap的介绍。
目录
Map集合
Map集合与Collection集合区别
Map常用子类
Map集合以及子类特点
Map常用方法
Map集合遍历
HashMap存储自定义键值
JDK9对集合添加的优化
Map集合
Map集合与Collection集合区别
1. Collection集合为单列集合，集合中的元素是孤立存在的，向集合中存储元素采用一个个的形式存储。
2. Map集合为双列集合，存储的是键值对。map集合中每个元素有键和值两部分组成，通过键可以找到对应的值。
注意：Map集合中不能包含重复的键，值可以重复；每个键只能对应一个值，每个值可以对应不同的键。
Map常用子类
HashMap
LinkedHashMap
还有一个treeMap集合，这里到后面学习过后整理。
注意：Map接口中的集合都有两个泛型变量
Map集合以及子类特点
Map集合特点：
1. Map集合是一个双列集合，一个元素包含两个值(一个key--K,一个value---V)
2. Map集合中的元素，key和value的数据类型可以相同，也可以不同
3. Map集合中的元素，key是不允许重复的，value可以重复
4. Map集合中的元素，key和value是一一对应
java.util.HashMap
HashMap集合特点：
1. HashMap集合底层是哈希表：查询的速度特别的快
JDK1.8之前：数组+单项链表
JDK1.8之后：数组+单向链表|红黑树（链表的长度超过8）：提高查询速度
2. HashMap集合是一个无序的集合，存储元素和取出元素的顺序可能不一致。
java.util.LinkedHashMap
LinkedHashMap特点：
1. LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2. LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的
Map常用方法
-
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。 -
public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。 -
public V get(Object key)根据指定的键，在Map集合中获取对应的值。 -
boolean containsKey(Object key)判断集合中是否包含指定的键。 -
public Set: 获取Map集合中所有的键，存储到Set集合中。keySet() -
public Set: 获取到Map集合中所有的键值对对象的集合(Set集合)。
注意：后面两种方法keySet()和entrySet()方法在Map遍历经常用到，下面一节介绍详细用法。
实例：
package demo1_Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
- public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
- public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，
返回被删除元素的值。
- public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
- boolean containsKey(Object key) 判断集合中是否包含指定的键。
- public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。
- public Set> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
*/
/*
Map集合的第二张遍历方式：通过键找值的方式
Map集合中的方法：
Set keySet() 返回次映射中包含的键的Set视图
实现步骤：
1.使用Map集合中的方法keySet()，把Map集合中所以的key取出来，存储到set集合中
2.遍历set集合，获取Map集合中的每一个key
3.通过Map集合中的方法get(key)，通过key找到
*/
public class Test01_MapMethod {
public static void main(String[] args) {
// method_RemoveGet();
method_Set();
}
//第一种遍历方式
public static void method_Set(){
Map map=new HashMap<>();
map.put("黄晓明","杨颖");
map.put("文章","马伊利");
map.put("冷锋","龙小云");
//1.获取
Set set=map.keySet();
//2.遍历
Iterator iterator = set.iterator();
while (iterator.hasNext()){
String key=iterator.next();
String value=map.get(key);
System.out.println(key+"==="+value);
}
}
//获取移除方法
private static void method_RemoveGet() {
//创建Map集合
Map map=new HashMap<>();
//添加键值对到集合中
map.put("黄晓明","杨颖");
map.put("文章","马伊利");
System.out.println(map);
//删除，返回值为键对应的值
System.out.println(map.remove("文章"));
System.out.println(map.get("黄晓明"));
}
}
Map集合遍历
Map集合遍历有两种方式：
1.通过键找值 2.遍历键值对
第一种遍历：通过键找值的方式
实现方法：
public Set: 获取Map集合中所有的键，存储到Set集合中。
实现步骤：
1.使用Map集合中的方法keySet()，把Map集合中所以的key取出来，存储到set集合中
2.遍历set集合，获取Map集合中的每一个key
3.通过Map集合中的方法get(key)，通过key找到value值
实例：
package demo1_Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
Map集合的第一种遍历方式：通过键找值的方式
Map集合中的方法：
Set keySet() 返回次映射中包含的键的Set视图
实现步骤：
1.使用Map集合中的方法keySet()，把Map集合中所以的key取出来，存储到set集合中
2.遍历set集合，获取Map集合中的每一个key
3.通过Map集合中的方法get(key)，通过key找到value值
*/
public class Test03_MapBianli {
public static void main(String[] args) {
method_BianLi();
}
private static void method_BianLi() {
Map map=new HashMap<>();
map.put("杨过","小龙女");
map.put("郭靖","黄蓉");
map.put("杨康","穆念慈");
map.put("杨铁心","包惜弱");
// 1.使用Map集合中的方法keySet()，把Map集合中所以的key取出来，存储到set集合中
Set set = map.keySet();
//2.遍历set集合，获取Map集合中的每一个key
Iterator iterator = set.iterator();
while (iterator.hasNext()){
String key=iterator.next();
//3.通过Map集合中的方法get(key)，通过key找到value值
System.out.println(key+"===="+map.get(key));
}
}
}
第二种遍历方式：通过遍历键值对的方式
实现方法：
public Set: 获取到Map集合中所有的键值对对象的集合(Set集合)。
实现步骤：
1.使用map集合中的方法entrySet()，把map集合中的多个Entry对象取出来，存储到Set集合中
2.遍历Set集合，获取每一个Entry对象
3.使用Entry对象中的getKey()和getValue()方法获取键与值
实例：
package demo1_Map;
/*
Map集合的第二种遍历方式：使用Entry对象遍历
Map集合中的方法：
Set 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 Test02_MapBianLi {
public static void main(String[] args) {
method_MapBian();
}
private static void method_MapBian(){
Map map = new HashMap<>();
map.put("黄晓明", "杨颖");
map.put("文章", "马伊利");
map.put("冷锋", "龙小云");
//1.使用map集合中的方法entrySet()，把map集合中的多个Entry对象取出来，存储到Set集合中
Set> entrySet = map.entrySet();
//2.遍历Set集合，获取每一个Entry对象
Iterator> iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry next = iterator.next();
//3.使用Entry对象中的getKey()和getValue()方法获取键与值
String key = next.getKey();
String value = next.getValue();
System.out.println(key + "==" + value);
}
}
}
HashMap存储自定义键值
-
当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
-
如果要保证map中存放的key和取出的顺序一致，可以使用
java.util.LinkedHashMap集合来存放。
实例：
每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
注意，学生姓名相同并且年龄相同视为同一名学生。
定义学生类并且重写hashCode和equals方法：
package demo1_Map;
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.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);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类：
package demo1_Map;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/*
hashMap存储自定义键值
*/
public class Test04_PersonTest {
public static void main(String[] args) {
//1.创建集合,LinkedHashMap存储，保证有序
Map mapPerson=new LinkedHashMap<>();
//2.添加Person对象
mapPerson.put(new Person("张三",19),"北京");
mapPerson.put(new Person("王五",20),"武汉");
mapPerson.put(new Person("李四",22),"上海");
//3.遍历，键找值方式
Set people = mapPerson.keySet();
for (Person person : people) {
String palce=mapPerson.get(person);
System.out.println(person.toString()+"===="+palce);
}
}
}
===============================
//测试结果
Person{name='张三', age=19}====北京
Person{name='王五', age=20}====武汉
Person{name='李四', age=22}====上海
Process finished with exit code 0
JDK9对集合添加的优化
JDK9新特性：
List接口，Set接口，Map接口：里面增加了一个静态的方法of，可以给集合一次性添加多个元素
static
使用前提：
当集合存储的元素的个数已经确定了，不再改变时使用
注意：
1. of方法只适用于List接口，Set接口，Map接口，不适用于接口的实现类。
2. of方法的返回值是一个不能改变的集合，集合不能再使用add,put方法添加元素，会抛出异常
3. Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛出异常
实例：
package demo1_Map;
import java.util.List;
import java.util.Map;
import java.util.Set;
/*
JDK9新特性
1:of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，
比如HashSet，ArrayList等待；
2:返回的集合是不可变的；
*/
public class Test05_New {
public static void main(String[] args) {
Set set=Set.of("上海","北京","武汉");
List list=List.of("小月亮","小行星","小太阳");
Map map=Map.of("杨过","小龙女","郭靖","黄蓉");
//输出
System.out.println( set);
System.out.println(list);
System.out.println(map);
}
}
========================================
//测试结果
[北京, 上海, 武汉]
[小月亮, 小行星, 小太阳]
{郭靖=黄蓉, 杨过=小龙女}
Process finished with exit code 0