一、概念
在Java中，Map 是一种用于存储键值对的数据结构。它提供了一种通过键来快速查找和访问值的方式。Map 接口有多个实现类，在常用的实现类中包括 HashMap、TreeMap 和 LinkedHashMap。
Map集合的特点：
（1）Map 是由键值对（Key-Value）组成的数据结构。每个键（Key）都是唯一的，而值（Value）可以重复 。如果键重复了，那么后面的值会替换前面的值。
（2）Map集合中的元素，Key和Value的数据类型可以相同，也可以不同，且Map 的键和值都可以为 null。
（3）Map里的Key和Value是一一对应的，并且Map 中的键值对没有固定的顺序。
二、Map中的常用方法
（1）public V put(K key, V value)：指定的键和值添加到Map集合中，返回值是V。
public static void main(String[] args) {
/* public V put (K key，V value) 返回值为：V
* 如果要存储的键值对，key不重复返回值V是null
* 如果要存储的键值对，key重复返回值V是被替换的value值
*/
Map<String, String> map=new HashMap<>();
map.put("学生1","张三");
String v=map.put("学生2","李四");
String v1=map.put("学生1","张三");
System.out.println(v+","+v1);
System.out.println(map);//替换了前面的值
}（2） public V remove(Object key) ： 把指定的键所对应的键值对元素在Map集合中删除，返回被删除的元素的值。
public static void main(String[] args) {
/* public V remove(Object key) 返回值：V
* 如果key存在，返回被删除的值
* 如果key不存在，返回null
* */
Map<String,Integer> map = new HashMap<>();
map.put("张三",1001);
map.put("李四",1002);
map.put("王伟",1003);
map.put("老六",1004);
System.out.println(map);
Integer t=map.remove("王伟");
Integer t1=map.remove("老九");
System.out.println("t:"+t+",t1:"+t1);
System.out.println(map);
}（3） public V get(Object key)：根据指定的键，在Map集合中获取对应的值。
public static void main(String[] args) {
/* public V remove (Object key):
* 如果key存在，返回对应的value值，如果key不存在，返回null
*/
Map<Integer, String> map = new HashMap<>();
map.put(2023,"七月");
map.put(2024,"八月");
map.put(2025,"九月");
map.put(2026,"十月");
String v1=map.get(2024);
String v2=map.get(2021);
System.out.println("v1:"+v1+",v2:"+v2);
}
（4）public boolean containsKey(Object key) ： 判断该集合中是否包含有此键。
public static void main(String[] args) {
/* boolean containsKey (Object key):
* 包含返回true，不包含返回false;
*/
Map<Integer, String> map = new HashMap<>();
map.put(2023,"七月");
map.put(2024,"八月");
map.put(2025,"九月");
map.put(2026,"十月");
boolean v1=map.containsKey(2023);
boolean v2=map.containsKey(2017);
System.out.println("v1:"+v1+",v2:"+v2);
}（5）public boolean containsValue(Object value)： 判断该集合中是否包含有此值。（参上）
（6）public Set<K> keySet() :获取Map集合中所有的键，存储到Set集合中。
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>();
map.put(2023,"七月");
map.put(2026,"八月");
map.put(2025,"九月");
map.put(2021,"十月");
Set<Integer> set = map.keySet();//使用keySet()方法获取所有的键并存储到Set集合中。
// 遍历输出所有的键
for(Integer a : set) {
System.out.println(a);
}
}（7）public Collection<V> values() ：获取Map集合中所有的值，存储到Collection集合中。
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("2023","七月");
map.put("2026","八月");
map.put("2025","九月");
map.put("2021","十月");
// 使用 values() 方法获取所有的值并存入到Collection集合中。
Collection<String> value=map.values();
for(String v:value){
System.out.println(v);
}
}（8）public Set<Map.Entry<K,V>> entrySet() ：获取到Map集合中所有的键值对，并将它们存储到一个 Set 集合中。
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("2023","七月");
map.put("2026","八月");
map.put("2025","九月");
map.put("2021","十月");
// 使用 entrySet() 方法获取所有的键值对,存入Set集合中
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println("K:"+key+",V:"+value);
}
}（9）public static interface Map.Entry<K,V> ：表示一个键值对的对象 ，可以把键值对包装成一个对象，该对象类型就是Entry类型。
public static void main(String[] args) {
// 创建一个键值对对象
Map.Entry<String, Integer> entry = new MyEntry<>("张三", 1001);
// 使用 Entry 对象获取键和值
String key = entry.getKey();
Integer value = entry.getValue();
// 输出键和值
System.out.println("Key: " + key);
System.out.println("Value: " + value);
}
static class MyEntry<K, V> implements Map.Entry<K, V> {
private K key;
private V value;
public MyEntry(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
}三、Map集合的遍历方式
（1）键找值法（键集遍历）
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三",1001);
map.put("李四",1002);
map.put("王伟",1003);
map.put("老六",1004);
for(String key : map.keySet()) {
Integer value =map.get(key);
System.out.println("K:"+key+",V:"+value);
}
}（2）键值对循环遍历
public static void main(String[] args){
Map<String, Integer> map = new HashMap<>();
map.put("张三",1001);
map.put("李四",1002);
map.put("王伟",1003);
map.put("老六",1004);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
// 使用foreach循环遍历键值对
for(Map.Entry<String, Integer> entry : entries) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println("V:"+key+",K:"+value);
}
}（3）迭代器遍历
public static void main(String[] args){
Map<String, Integer> map = new HashMap<>();
map.put("张三",1001);
map.put("李四",1002);
map.put("王伟",1003);
map.put("老六",1004);
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println("K:"+key+",V:"+value);
}
}四、Map接口常用的实现类
（1）HashMap
HashMap是基于哈希表实现的Map，提供快速的插入、删除和查找操作。它不保证元素的顺序，允许使用null键和null值。
4.1.1、特点：
<1>哈希表实现：HashMap内部使用哈希表数据结构，通过计算键的哈希码来确定元素在哈希表中的位置，从而实现快速的插入、删除和查找操作。平均情况下，这些操作的时间复杂度为O(1)。
<2>键值对存储：HashMap存储的数据是键值对（Key-Value）形式，每个键都是唯一的，可以用来查找对应的值。它允许使用null作为键，也允许使用null作为值。
<3>无序性：HashMap不保证元素的顺序。即使插入的顺序是固定的，遍历时得到的元素顺序也不一定相同。如果需要有序的Map，可以使用TreeMap或LinkedHashMap。\
<4>非线程安全：HashMap是非线程安全的，如果多个线程同时操作同一个HashMap对象，可能会导致不可预期的结果。如果需要在并发环境中使用Map，可以考虑使用ConcurrentHashMap。
<5>扩容与负载因子：HashMap在内部数组的填充程度达到一定比例（负载因子）后会触发扩容，以保持较低的哈希冲突率。扩容涉及到重新计算哈希码和重新分配元素存储位置，可能会导致性能略微下降。可以在创建HashMap时指定初始容量和负载因子，以适应不同的场景需求。
4.1.2、HashMap存储自定义类型键值：
HashMap存储自定义类型键值，Map集合保证key是唯一的：作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一。
class Personbest{
private String name;
private int age;
public Personbest(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Personbest [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Personbest other = (Personbest) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class Test18 {
public static void main(String[] args){
HashMap<Personbest,String> map = new HashMap<>();
Personbest best1 = new Personbest("张三",18);
Personbest best2 = new Personbest("李四",20);
Personbest best3 = new Personbest("王伟",8);
Personbest best4 = new Personbest("老六",66);
map.put(best1,"十七");
map.put(best2,"七七");
map.put(best3,"五五");
map.put(best4,"四六");
String v1=map.get(best4);
String v2=map.get(best3);
System.out.println(v1);
System.out.println(v2);
System.out.println(map);
System.out.println(map.size());
}
}
在上述示例中，Person类正确实现了hashCode()和equals()方法，允许将其作为HashMap的键。通过相同属性的键对象可以成功获取对应的值。
注意：当自定义类型的属性发生变化时，可能导致哈希码和相等性判断发生改变，如果已经将此对象作为HashMap的键使用，可能会导致无法正确地获取值。因此，在将对象用作HashMap的键之前，应尽量确保其属性不可变或不会被修改。
（2）LinkedHashMap
LinkedHashMap继承自HashMap，通过双向链表维护了元素的插入顺序或访问顺序。它保留了元素的插入顺序或访问顺序，并且支持快速插入、删除和查找操作。
特点：
<1>有序性：LinkedHashMap保持元素的插入顺序或访问顺序（可以通过构造函数参数来选择）。即使在遍历时，得到的元素顺序也是按照插入或访问的顺序。
<2>哈希表与双向链表结合：LinkedHashMap内部通过哈希表和双向链表两种数据结构相结合来实现。哈希表用于快速定位元素，双向链表用于维护元素的插入顺序或访问顺序。
<3>高效性能：LinkedHashMap对于插入、删除和查找操作具有快速的性能，平均情况下的时间复杂度为O(1)。同时，由于使用了双向链表来维护顺序，对于迭代遍历操作也能够快速地获取有序的元素。
<4>非线程安全：与HashMap一样，LinkedHashMap也是非线程安全的。如果在并发环境中需要使用LinkedHashMap，可以考虑使用ConcurrentLinkedHashMap。
<5>可指定访问顺序：LinkedHashMap提供了两种顺序模式，即插入顺序和访问顺序。在插入顺序模式下，元素的顺序按照它们被添加的顺序进行排列。在访问顺序模式下，元素的顺序会根据被访问的顺序进行调整，每次访问一个元素时，该元素会被移动到链表的尾部。
扫一扫
9088
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
