1、Map集合
· 现实生活与开发中，我们常会看到这样的一类集合：用户ID与账户信息、学生姓名与考试成绩、IP地址与主机名等，这种一一对应的关系，就称作映射。Java提供了专门的集合框架用来存储这种映射关系的对象，即java.util.Map接口。
1.1 Map接口概述
Map与Collection并列存在。用于保存具有映射关系的数据：key-value
Collection集合称为单列集合，元素是孤立存在的（理解为单身）。Map集合称为双列集合，元素是成对存在的(理解为夫妻)。
Map 中的 key 和 value 都可以是任何引用类型的数据。但常用String类作为Map的“键”。
Map接口的常用实现类：HashMap、LinkedHashMap、TreeMap和`Properties。其中，HashMap是 Map 接口使用频率最高的实现类。
1.2 Map中key-value特点
这里主要以HashMap为例说明。HashMap中存储的key、value的特点如下：
Map 中的 key用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value，不同key对应的value可以重复。value所在的类要重写equals()方法。
key和value构成一个entry。所有的entry彼此之间是无序的、不可重复的。
1.3 Map与Collection集合区别
Collection集合
单列集合，一次只能添加一个元素
有的是有索引，有的没有索引
有的集合可以存储重复的元素，有的则不可以
有的元素是无序的，有的是有序的
Map集合
Map集合是双列集合，由Key和Value组成
Key是不允许重复的，Value是允许重复
Key允许存null值的，但是只能存储唯一的一个
1.4 Map接口中常用的方法
1.4.1 添加、修改操作
public Object put(Object key,Object value)
将指定key-value添加到(或修改)当前map对象中
public void putAll(Map m)
将m中的所有key-value对存放到当前map中
package com.suyv.map;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 10:26
*@Description: Map接口的添加和修改方法
*/
public class MapDemo01 {
// put(Object key,Object value)
@Test
public void Test01(){
Map map = new HashMap();
// 添加数据
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
// 修改数据
map.put("1","红楼梦");
System.out.println(map); // {1=红楼梦, 2=西游记}
}
// putAll(Map m) 添加数据
@Test
public void Test02(){
Map map1 = new HashMap();
// 添加数据
map1.put("1","三国演义");
map1.put("2","西游记");
System.out.println(map1); // {1=三国演义, 2=西游记}
Map map2 = new HashMap();
// 添加数据
map2.put("3","水浒传");
map2.put("4","红楼梦");
System.out.println(map2); // {3=水浒传, 4=红楼梦}
map1.putAll(map2);
System.out.println(map1); // {1=三国演义, 2=西游记, 3=水浒传, 4=红楼梦}
}
// putAll(Map m) 修改数据
@Test
public void Test03(){
Map map1 = new HashMap();
// 添加数据
map1.put("1","三国演义");
map1.put("2","西游记");
System.out.println(map1); // {1=三国演义, 2=西游记}
Map map2 = new HashMap();
// 添加数据
map2.put("1","水浒传");
map2.put("2","红楼梦");
System.out.println(map2); // {1=水浒传, 2=红楼梦}
map1.putAll(map2);
System.out.println(map1); // {1=水浒传, 2=红楼梦}
}
}1.4.2 删除操作：
public Object remove(Object key)
移除指定key的key-value对，并返回value
public void clear()
清空当前map中的所有数据
package com.suyv.map;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 10:37
*@Description: Map接口的删除方法
*/
public class MapDemo02 {
/*public Object remove(Object key)
移除指定key的key-value对，并返回value
public void clear()
清空当前map中的所有数据*/
// remove(Object key)
// 移除指定key的key-value对，并返回value
@Test
public void Test01(){
Map map = new HashMap();
// 添加数据
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
System.out.println(map.remove("1")); // 三国演义
System.out.println(map); // {2=西游记}
}
// clear()
// 清空当前map中的所有数据
@Test
public void Test02(){
Map map = new HashMap();
// 添加数据
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
map.clear();
System.out.println(map); // {}
}
}1.4.3 元素查询的操作：
public Object get(Object key)
获取指定key对应的value
public boolean containsKey(Object key)
是否包含指定的key
public boolean containsValue(Object value)
是否包含指定的value
public int size()
返回map中key-value对的个数
public boolean isEmpty()
判断当前map是否为空
public boolean equals(Object obj)
判断当前map和参数对象obj是否相等
package com.suyv.map;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 10:43
*@Description: Map集合中元素查询方法
*/
public class MapDemo03 {
// get(Object key)
// 获取指定key对应的value
@Test
public void Test01(){
Map map = new HashMap();
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
System.out.println(map.get("1")); // 三国演义
}
// containsKey(Object key)
// 是否包含指定的key
@Test
public void Test02(){
Map map = new HashMap();
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
System.out.println(map.containsKey("1")); // true
System.out.println(map.containsKey("3")); // false
}
// containsValue(Object value)
// 是否包含指定的value
@Test
public void Test03(){
Map map = new HashMap();
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
System.out.println(map.containsValue("三国演义")); // true
System.out.println(map.containsKey("红楼梦")); // false
}
// size()
// 返回map中key-value对的个数
@Test
public void Test04(){
Map map = new HashMap();
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
System.out.println(map.size()); // 2
}
// isEmpty()
// 判断当前map是否为空
@Test
public void Test05(){
Map map = new HashMap();
System.out.println(map.isEmpty()); // true
map.put("1","三国演义");
map.put("2","西游记");
System.out.println(map); // {1=三国演义, 2=西游记}
System.out.println(map.isEmpty()); // false
}
// equals(Object obj)
// 判断当前map和参数对象obj是否相等
@Test
public void Test06(){
Map map1 = new HashMap();
map1.put("1","三国演义");
map1.put("2","西游记");
System.out.println(map1); // {1=三国演义, 2=西游记}
Map map2 = new HashMap();
map2.put("1","三国演义");
map2.put("2","西游记");
System.out.println(map2); // {1=三国演义, 2=西游记}
System.out.println(map1.equals(map2)); // true
map2.remove("1");
System.out.println(map1.equals(map2)); // false
}
}1.5 Map集合的遍历
Map集合遍历的方法：
public Set keySet()
返回所有key构成的Set集合
public Collection values()
返回所有value构成的Collection集合
public Set entrySet()
返回所有key-value对构成的Set集合
package com.suyv.map;
import org.junit.Test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 10:54
*@Description: Map集合的遍历
*/
public class MapDemo04 {
// public Set keySet()
// 返回所有key构成的Set集合
@Test
public void Test01(){
Map map = new HashMap();
map.put("1","三国演义");
map.put("2","西游记");
map.put("3","水浒传");
map.put("4","红楼梦");
System.out.println(map); // {1=三国演义, 2=西游记, 3=水浒传, 4=红楼梦}
Set keySet = map.keySet();
for (Object obj : keySet) {
System.out.println(obj); // 1 2 3 4
}
}
// public Collection values()
// 返回所有value构成的Collection集合
@Test
public void Test02(){
Map map = new HashMap();
map.put("1","三国演义");
map.put("2","西游记");
map.put("3","水浒传");
map.put("4","红楼梦");
System.out.println(map); // {1=三国演义, 2=西游记, 3=水浒传, 4=红楼梦}
Collection values = map.values();
for (Object obj : values) {
System.out.println(obj); // 三国演义 西游记 水浒传 红楼梦
}
}
// public Set entrySet()
// 返回所有key-value对构成的Set集合
@Test
public void Test03(){
Map map = new HashMap();
map.put("1","三国演义");
map.put("2","西游记");
map.put("3","水浒传");
map.put("4","红楼梦");
System.out.println(map); // {1=三国演义, 2=西游记, 3=水浒传, 4=红楼梦}
Set entrySet = map.entrySet();
for (Object obj : entrySet) {
System.out.println(obj); // 1=三国演义 2=西游记 3=水浒传 4=红楼梦
}
}
}1.6 Map存储自定义类型元素
需求
每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
要求： 学生姓名相同并且年龄相同视为同一名学生。
编写学生类
package com.suyv.map;
import java.util.Objects;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 11:35
*@Description: 学生实体类Student
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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 String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}编写测试类
package com.suyv.map;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 11:37
*@Description: 自定义实体类的测试类
*/
public class MapDemo05 {
@Test
public void Test01(){
//1、创建Map集合对象
Map<Student,String> map = new HashMap<Student,String>();
//2、添加元素
map.put(new Student("lisi",28), "上海");
map.put(new Student("wangwu",22), "北京");
map.put(new Student("zhaoliu",24), "成都");
map.put(new Student("zhouqi",25), "广州");
map.put(new Student("wangwu",22), "南京");
//3、取出元素、键找值方式
Set<Student> keySet = map.keySet();
for(Student key: keySet){
String value = map.get(key);
System.out.println(key.toString()+"....."+value);
// Student{name='zhaoliu', age=24}.....成都
// Student{name='lisi', age=28}.....上海
// Student{name='wangwu', age=22}.....南京
// Student{name='zhouqi', age=25}.....广州
}
}
}当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须重写对象的hashCode和equals方法。
如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。
2、Map的主要实现类：HashMap
2.1 HashMap概述
HashMap是 Map 接口使用频率最高的实现类。
HashMap是线程不安全的。允许添加 null 键和 null 值。
存储数据采用的哈希表结构，底层使用数组+单向链表+红黑树进行key-value数据的存储。与HashSet一样，元素的存取顺序不能保证一致。
HashMap 判断两个key相等的标准是：两个 key 的hashCode值相等，通过 equals() 方法返回 true。
HashMap 判断两个value相等的标准是：两个 value 通过 equals() 方法返回 true。
2.2 练习
2.2.1 练习--二级联动
将省份和城市的名称保存在集合中，当用户选择省份以后，二级联动，显示对应省份的地级市供用户选择。
效果演示：
package com.suyv.hashMap;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 12:08
*@Description: HashMap练习实现二级联动
*/
public class HashMapDemo01 {
public static void main(String[] args) {
Map model = new HashMap();
model.put("北京", new String[] {"北京"});
model.put("上海", new String[] {"上海"});
model.put("天津", new String[] {"天津"});
model.put("重庆", new String[] {"重庆"});
model.put("黑龙江", new String[] {"哈尔滨","齐齐哈尔","牡丹江","大庆","伊春","双鸭山","绥化"});
model.put("吉林", new String[] {"长春","延边","吉林","白山","白城","四平","松原"});
model.put("河北", new String[] {"石家庄","张家口","邯郸","邢台","唐山","保定","秦皇岛"});
model.put("河南", new String[] {"郑州","开封","洛阳","周口","新乡","驻马店","安阳"});
Set keySet = model.keySet();
for(Object s : keySet) {
System.out.print(s + "\t");
}
System.out.println();
System.out.println("请选择你所在的省份：");
Scanner scan = new Scanner(System.in);
String province = scan.next();
String[] citys = (String[])model.get(province);
for(String city : citys) {
System.out.print(city + "\t");
}
System.out.println();
System.out.println("请选择你所在的城市：");
String city = scan.next();
System.out.println("信息登记完毕");
}
}3、Map实现类之二：LinkedHashMap
LinkedHashMap 是 HashMap 的子类
存储数据采用的哈希表结构+链表结构，在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的先后顺序，可以保证遍历元素时，与添加的顺序一致。
通过哈希表结构可以保证键的唯一、不重复，需要键所在类重写hashCode()方法、equals()方法。
总结：有序，key唯一
package com.suyv.hashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 12:15
*@Description: LinkedHashMap类的使用
*/
public class LinkedHashMapDemo {
public static void main(String[] args) {
LinkedHashMap map = new LinkedHashMap();
map.put("王五", 13000.0);
map.put("张三", 10000.0);
//key相同，新的value会覆盖原来的value
//因为String重写了hashCode和equals方法
map.put("张三", 12000.0);
map.put("李四", 14000.0);
//HashMap支持key和value为null值
String name = null;
Double salary = null;
map.put(name, salary);
Set entrySet = map.entrySet();
for (Object obj : entrySet) {
Map.Entry entry = (Map.Entry)obj;
System.out.println(entry);
// 王五=13000.0
// 张三=12000.0
// 李四=14000.0
// null=null
}
}
}4、Map实现类之三：TreeMap
TreeMap存储 key-value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 key-value 对处于有序状态。
TreeSet底层使用红黑树结构存储数据
TreeMap 的 Key 的排序：
自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
定制排序：创建 TreeMap 时，构造器传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口
TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。
package com.suyv.hashMap;
import org.junit.Test;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 12:21
*@Description: TreeMap的使用
*/
public class TreeMapDemo {
// 自然排序的使用
@Test
public void Test01(){
TreeMap map = new TreeMap();
map.put("CC",45);
map.put("MM",78);
map.put("DD",56);
map.put("GG",89);
map.put("JJ",99);
Set entrySet = map.entrySet();
for(Object entry : entrySet){
System.out.println(entry);
// CC=45
// DD=56
// GG=89
// JJ=99
// MM=78
}
}
// 自然排序--自定义类
@Test
public void Test02(){
TreeMap map = new TreeMap();
map.put(new User("Tom",12),67);
map.put(new User("Rose",23),"87");
map.put(new User("Jerry",2),88);
map.put(new User("Eric",18),45);
map.put(new User("Tommy",44),77);
map.put(new User("Jim",23),88);
map.put(new User("Maria",18),34);
Set entrySet = map.entrySet();
for(Object entry : entrySet){
System.out.println(entry);
// User{name='Jerry', age=2}=88
// User{name='Tom', age=12}=67
// User{name='Maria', age=18}=34
// User{name='Eric', age=18}=45
// User{name='Rose', age=23}=87
// User{name='Jim', age=23}=88
// User{name='Tommy', age=44}=77
}
}
// 定制排序的使用
@Test
public void Test03(){
//按照User的姓名的从小到大的顺序排列
TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return u1.getName().compareTo(u2.getName());
}
throw new RuntimeException("输入的类型不匹配");
}
});
map.put(new User("Tom",12),67);
map.put(new User("Rose",23),"87");
map.put(new User("Jerry",2),88);
map.put(new User("Eric",18),45);
map.put(new User("Tommy",44),77);
map.put(new User("Jim",23),88);
map.put(new User("Maria",18),34);
Set entrySet = map.entrySet();
for(Object entry : entrySet){
System.out.println(entry);
// User{name='Eric', age=18}=45
// User{name='Jerry', age=2}=88
// User{name='Jim', age=23}=88
// User{name='Maria', age=18}=34
// User{name='Rose', age=23}=87
// User{name='Tom', age=12}=67
// User{name='Tommy', age=44}=77
}
}
}
// 定义实体类
class User implements Comparable{
private String name;
private int age;
public User() {
}
public User(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 String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
// 按照age从小到大的顺序排列，如果age相同，则按照name从大到小的顺序排列
@Override
public int compareTo(Object o) {
if(this == o){
return 0;
}
if(o instanceof User){
User user = (User)o;
int value = this.age - user.age;
if(value != 0){
return value;
}
return -this.name.compareTo(user.name);
}
throw new RuntimeException("输入的类型不匹配");
}
}5、Map实现类之四：Hashtable
Hashtable是Map接口的古老实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。
Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构（数组+单向链表），查询速度快。
与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。
与HashMap不同，Hashtable 不允许使用 null 作为 key 或 value。
面试题：Hashtable和HashMap的区别
HashMap:底层是一个哈希表（jdk7:数组+链表;jdk8:数组+链表+红黑树）,是一个线程不安全的集合,执行效率高
Hashtable:底层也是一个哈希表（数组+链表）,是一个线程安全的集合,执行效率低
HashMap集合:可以存储null的键、null的值
Hashtable集合,不能存储null的键、null的值
Hashtable和Vector集合一样,在jdk1.2版本之后被更先进的集合(HashMap,ArrayList)取代了。所以HashMap是Map的主要实现类，Hashtable是Map的古老实现类。
Hashtable的子类Properties（配置文件）依然活跃在历史舞台
Properties集合是一个唯一和IO流相结合的集合
6、Map实现类之五：Properties
Properties 类是 Hashtable 的子类，该对象用于处理属性文件
由于属性文件里的 key、value 都是字符串类型，所以 Properties 中要求 key 和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法
package com.suyv.hashMap;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-18 13:05
*@Description: Properties类的使用
*/
public class PropertiesDemo {
@Test
public void Test01() {
Properties properties = System.getProperties();
String fileEncoding = properties.getProperty("file.encoding");//当前源文件字符编码
System.out.println("fileEncoding = " + fileEncoding);
}
@Test
public void Test02() {
Properties properties = new Properties();
properties.setProperty("user","songhk");
properties.setProperty("password","123456");
System.out.println(properties);
}
@Test
public void Test03() throws IOException {
// File file = new File("jdbc.properties");
// System.out.println(file.getAbsoluteFile());
Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);
}
}
