文章目录
前言
这篇文章主要介绍了Map集合的遍历方式和简单的底层原理
遍历时候需要了解一下Map集合的方法，所有需要先学习一下Map方法。
一、认识Map集合
Map集合称为双列集合，一次需要存一对数据做为一个元素, 格式：{key1=value1 , key2=value2 , key3=value3 , …}
Map集合的每个元素分为两部分:key和value，key称为键，value称为值，整体叫键值对，因此Map也叫“键值对集合”
Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值
二、Map集合体系
体系图
Map集合体系的特点
HashMap: 无序、不重复 （用的最多）
LinkedHashMap ：有序、不重复
TreeMap: 按照大小默认升序排序、不重复
三、Map集合常用方法
public V put(K key,V value) 添加/修改元素
public int size() 获取集合的大小
public void clear() 清空集合
public boolean isEmpty() 判断集合是否为空
public V get(Object key) 根据键获取对应值
public V remove(Object key) 根据键删除整个元素
public boolean containsKey(Object key) 判断是否包含某个键
public boolean containsValue(Object value) 判断是否包含某个值
public Set keySet() 获取全部键的集合
public Collection values() 获取Map集合的全部值
//向map中存入西游四人组的编号和姓名 001-玄奘 002-悟空 003-悟能 004-悟净
Map<String, String> map = new HashMap<>();
//V put(K key,V value) 添加元素
map.put("001","玄奘");
map.put("002","悟空");
map.put("003","悟能");
map.put("004","悟净");
//int size() 获取集合的大小
System.out.println(map.size());
//boolean isEmpty() 判断集合是否为空，为空返回true, 反之
System.out.println(map.isEmpty());
//V get(Object key) 根据键获取对应值
System.out.println(map.get("002"));
//V remove(Object key) 根据键删除整个元素
System.out.println(map.remove("001"));
//boolean containsKey(Object key) 判断是否包含某个键
System.out.println(map.containsKey("001"));
//boolean containsValue(Object value) 判断是否包含某个值
System.out.println(map.containsValue("悟净"));
//Set<K> keySet() 获取全部键的集合
System.out.println(map.keySet());
//Collection<V> values() 获取Map集合的全部值
System.out.println(map.values());
//void clear() 清空集合
map.clear();
四、Map集合的遍历
遍历方式一
首先要学一个方法：
public Set keySet() 获取所有键的集合
根据键使用增强for遍历所需要的值
HashMap<String, String> map = new HashMap<>();
map.put("001", "玄奘");
map.put("002", "悟空");
map.put("003", "悟能");
map.put("004", "悟净");
test1(map);
private static void test1(HashMap<String, String> map) {
Set<String> strings = map.keySet();
for (String key:strings) {
System.out.println(map.get(key));
}
}
遍历方式二
先学方法
Set<Map.Entry<K, V>> entrySet() 获取所有“键值对”的集合
K getKey() 获取键
V getValue() 获取值
HashMap<String, String> map = new HashMap<>();
map.put("001", "玄奘");
map.put("002", "悟空");
map.put("003", "悟能");
map.put("004", "悟净");
test2(map);
private static void test2(HashMap<String, String> map) {
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getValue());
}
}
遍历方式三
使用lambda表达式遍历
HashMap<String, String> map = new HashMap<>();
map.put("001", "玄奘");
map.put("002", "悟空");
map.put("003", "悟能");
map.put("004", "悟净");
test3(map);
private static void test3(HashMap<String, String> map) {
map.forEach((k,v)-> System.out.println(v));
}
五、HashMap
底层原理
HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。
实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。
JDK8之前，哈希表 = 数组+链表
JDK8开始，哈希表 = 数组+链表+红黑树
哈希表是一种增删改查数据，性能都较好的数据结构。
HashMap的特点
HashMap集合是一种增删改查数据，性能都较好的集合
但是它是无序，不能重复，没有索引支持的（由键决定特点）
HashMap的键依赖hashCode方法和equals方法保证键的唯一
如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。
public class Demo4 {
public static void main(String[] args) {
//1. 创建一个Map集合
HashMap<Student, String> map = new HashMap<>();
map.put(new Student("李四",13),"北京");
map.put(new Student("李一",13),"上海");
map.put(new Student("李三",13),"深圳");
map.put(new Student("李三",13),"广州");
//2. 存储三个学生和地址
Set<Student> students = map.keySet();
for (Student stu:students){
System.out.println(stu+map.get(stu));
}
//3. 遍历打印
}
}
class Student {
private String name;
private int 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);
}
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 +
'}';
}
}
六、LinkedHashMap
底层原理
底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)
实际上：原来学习的LinkedHashSet集合的底层原理就是LinkedHashMap
LinkedHashMap的特点
LinkedHashMap : 有序、不重复
public static void main(String[] args) {
//创建LinkedHashMap
LinkedHashMap<String, String> map = new LinkedHashMap<>();
map.put("001","Aa");
map.put("002","Bb");
map.put("003","Cc");
map.put("003","dd");
//保存数据
System.out.println(map);
//观察顺序
}
七、TreeMap
底层原理
原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。
TreeMap的特点
不重复、无索引、可排序(按照键的大小默认升序排序，只能对键排序)
TreeMap集合同样也支持两种方式来指定排序规则
让类实现Comparable接口，重写比较规则。
TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。
public class Demo6 {
private String put;
public static void main(String[] args) {
//创建集合
Map<Teacher, String> map = new TreeMap<>((o1, o2) -> o1.getAge() > o2.getAge() ? 1:-1);
map.put(new Teacher("张三", 21), "河北");
map.put(new Teacher("李四", 20), "山东");
map.put(new Teacher("王五", 19), "山西");
map.put(new Teacher("赵六", 21), "河南");
map.forEach((k, v) -> {
if ("王五".equals(k.getName())){
map.remove(k);
}
System.out.println(k + "-----" + v);
});
map.forEach((k, v) -> {
System.out.println(k + "-----" + v);
});
}
}
class Teacher {
private String name;
private int age;
public Teacher() {
}
public Teacher(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 "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Teacher teacher = (Teacher) o;
return age == teacher.age && Objects.equals(name, teacher.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
总结
在Java中，Map接口是一个双列集合，用于存储键-值对（key-value pairs）。每个键都是唯一的，而一个键可以对应一个值。Map接口提供了插入、删除、更新和查询键值对的操作。Java标准库中几个常见的实现类包括：
HashMap：基于哈希表实现，无序，允许一个null键和多个null值，非线程安全，查询速度快，是最常用的Map实现类。
LinkedHashMap：基于哈希表和双向链表实现，有序（按照插入顺序或访问顺序），其他特性和HashMap相同，适合需要保持插入或访问顺序的场景。
TreeMap：基于红黑树实现，键需实现Comparable或提供Comparator，保证键的自然排序或定制排序，因此它是有序的，适用于需要按键排序的场景