2024年Java最新Java Review (二十九、集合----- Map 集合），阿里Java笔试

2401_84692382

已于 2024-05-05 19:48:08 修改

阅读量907

点赞数 29

分类专栏：程序员文章标签： java mfc 开发语言

于 2024-05-05 19:48:07 首次发布

本文链接：https://blog.csdn.net/2401_84692382/article/details/138472415

版权

程序员专栏收录该内容

102 篇文章 1 订阅

订阅专栏

读者福利

分享一份自己整理好的Java面试手册，还有一些面试题pdf

不要停下自己学习的脚步

字节跳动的面试分享，为了拿下这个offer鬼知道我经历了什么

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

图一：Map集合结构图

在这里插入图片描述

Map用于保存具有映射关系的数据，因此 Map 集合里保存着两组值，一组值用于保存 Map 里的 key 另外一组值用于保存 Map 里的 value ， key 和 value 都

可以是任何引用类型的数据。 Map 的 key 不允许重复，即同一个 Map 对象的任何两个 key 通过 equals 方法比较总是返回 false 。

key 和 value 之间存在单向一对一关系，即通过指定的 key，总能找到唯一的、确定的 value 。从 Map 中取出数数据时只要给出指定的 key ，就可以取出对应的value 。如果把 Map 的两组值拆开来看， Map 里的数据有如图二所示的结构。

图二：分开看 Map 的 key 组和 value 组

在这里插入图片描述

从图二中可以看出，如果把 Map 里的所有 key数据组放在一起来看，它们就组成了一个 Set 集合(所有的 key 没有顺序， key 与 key 之间不能重复) ，实际Map 确实包含了一个 keySet()方法，用于返回 Map 里所有 key 组成的 Set 集合。

实际上，Map的实现类和子接口中 key 集的存储形式和对应Set 集合中元素的存储形式完全相同。

Set 与 Map 之间的关系非常密切。虽然 Map中放的元素是 key-value 对， Set 集合中放的元素是单个对象，但如果把 key-value 对中的 value 当成 key 的附庸 : key 在哪里， value就跟在哪里。这样就可以像对待 Set 一样来对待 Map 了。事实上， Map 提供了一个 Entry内部类来封装 key-value对，而计算 Entry存储时则只考虑 Enume封装的 key。从 Java源代码来看， Java则是先实现了 Map ，然后通过包装一个所有 Value都为null的Map来实现Set集合。

如果把 Map 里的所有 value 放在一起来看，它们又非常类似于一个 List: 元素与元素之间可以重复，每个元素可以根据索引来查找，只是 Map 中的索引不再使用整数值，而是以另一个对象作为索引。如果需要从 List 集合中取出元素，则需要提供该元素的数字索引 ; 如果需要从 Map 中取出元素，则需要提供该元素的 key 索引。因此， Map 有时也被称为字典，或关联数组。

Map 接口中定义了如下常用的方法 :

void clear(): 删除该 Map 对象中的所有 key-value 对。
boolean containsKey(Object key): 查询 Map 中是否包含指定的 key ，如果包含则返回 true 。
boolean containsValue(Object value): 查询 Map 中是否包含一个或多个 value ，如果包含则返回 true ，
Set entrySet(): 返回 Map 中包含的 key-value 对所组成的 Set 集合，每个集合元素都是 Map.Entry(Entry 是 Map 的内部类)对象。
Object get(Object key): 返回指定 key 所对应的 value; 如果此 Map 中不包含该 key ，则返回 null 。
boolean isEmpty(): 查询该 Map 是否为空(即不包含任何 key-value 对 ) ，如果为空则返回 true 。
Set keySet(): 返回该 Map 中所有 key 组成的 Set 集合。

Object put(Object key, Object value): 添加一个 key-value 对，如果当前 Map 中己有一个与该 key相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。

void putAll(Map m): 将指定 Map 中的 key-value 对复制到本 Map 中。
Object remove(Object key): 删除指定 key 所对应的 key-value 对，返回被删除 key 所关联的 value ，如果该 key 不存在，则返回 null 。
boolean remove(Object key, Object value): 这是 Java 8 新增的方法，删除指定 key 、 value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true ，否则返回 false 。
int sizeO : 返回该 Map 里的 key-value 对的个数。
Collection values() : 返回该 Map 里所有 value 组成的 Collection 。

Map 中包括一个内部类 Entry，该类封装了一个 key-value 对。 Entry 包含如下三个方法:

Object getKey(): 返回该 En町里包含的 key 值。
Object getValue(): 返回该 Entry 里包含的 value 值。
Object setValue(V value): 设置该 Entry 里包含的 value 值，井返回新设置的 value 值。

下面程序示范了 Map 的基本功能:

MapTest.java

public class MapTest

{

public static void main(String[] args)

{

Map map = new HashMap();

// 成对放入多个key-value对

map.put(“疯狂Java讲义” , 109);

map.put(“疯狂iOS讲义” , 10);

map.put(“疯狂Ajax讲义” , 79);

// 多次放入的key-value对中value可以重复

map.put(“轻量级Java EE企业应用实战” , 99);

// 放入重复的key时，新的value会覆盖原有的value

// 如果新的value覆盖了原有的value，该方法返回被覆盖的value

System.out.println(map.put(“疯狂iOS讲义” , 99)); // 输出10

System.out.println(map); // 输出的Map集合包含4个key-value对

// 判断是否包含指定key

System.out.println(“是否包含值为疯狂iOS讲义 key：”

map.containsKey(“疯狂iOS讲义”)); // 输出true

// 判断是否包含指定value

System.out.println(“是否包含值为 99 value：”

map.containsValue(99)); // 输出true

// 获取Map集合的所有key组成的集合，通过遍历key来实现遍历所有key-value对

for (Object key : map.keySet() )

{

// map.get(key)方法获取指定key对应的value

System.out.println(key + “–>” + map.get(key));

}

map.remove(“疯狂Ajax讲义”); // 根据key来删除key-value对。

System.out.println(map); // 输出结果不再包含疯狂Ajax讲义=79 的key-value对

}

Java 8 除为 Map 增加了 remove(Object key , Object value)默认方法之外，还增加了如下方法：

Object compute(Object key, BiFunction remappingFunction) : 该方法使用 remappingFunction 根据原 key-value 对计算一个新 value 。只要新 value 不为 null. 就使用新 value 覆盖原 value ; 如果原value 不为 null ，但新 value 为 null ，则删除原 key-value 对;如果原 value 、新 value 同时为 null ，那么该方法不改变任何 key-value 对，直接返回 null 。
Object computeIfAbsent(Object key, Function mappingFunction): 如果传给该方法的 key 参数在Map 中对应的 value 为 null ，则使用 mappingFunction 根据 key 计算一个新的结果，如果计算结果不为 null ，则用计算结果覆盖原有的value 。如果原 Map 原来不包括该 key，那么该方法可能会添加一组 key-value 对。
Object computeIfPresent(Object key, BiFunction remappingFunction): 如果传给该方法的 key 参数在 Map 中对应的 value 不为 null. 该方法将使用 remappingFunction 根据原 key、 value 计算一个新的结果，如果计算结果不为 null. 则使用该结果覆盖原来的 value; 如果计算结果为 null.则删除原 key-value 对。
void forEach(BiConsumer action): 该方法是 Java 8 为 Map 新增的一个遍历 key-value 对的方法，通过该方法可以更简洁地遍历 Map 的 key-value 对。
Object getOrDefault(Object key, V defaultValue) : 获取指定 key 对应的 value 。如果该 key 不存在，则返回 defaultValue 。
Object merge(Object key, Object value, BiFunction remappingFunction): 该方法会先根据 key 参数获取该 Map 中对应的 value 。如果获取的 value 为 null. 则直接用传入的 value 覆盖原有的 value(在这种情况下，可能要添加一组 key-value 对) ;如果获取的 value 不为 null ，则使用remappingFunction 函数根据原 value 、新 value 计算一个新的结果，并用得到的结果去覆盖原有的 value 。
Object putlfAbsent(Object key, Object value): 该方法会自动检测指定 key 对应的 value 是否为 null，如果该 key 对应的 value 为 null. 该方法将会用新 value 代替原来的 null 值。
Object replace(Object key, Object value): 将 Map 中指定 key 对应的 value 替换成新 value 。与传统put()方法不同的是，该方法不可能添加新的 key-value 对。如果尝试替换的 key 在原 Map 中不存在，该方法不会添加 key-value 对，而是返回 null 。
boolean replace(K key, V oldValue, V newValue): 将 Map 中指定 key-value 对的原 value 替换成新value 。如果在 Map 中找到指定的 key-value 对，则执行替换并返回 true ，否则返回 false 。
replaceAll(BíFunction function): 该力活使用 BiFunction 别原 key-value 对执行计算，并将计算结果作为该 key-value 对的 value 值。Object computeIfAbsent(Object key, Function mappingFunction): 如果传给该方法的 key 参数在Map 中对应的 value 为 null ，则使用 mappingFunction 根据 key 计算一个新的结果，如果计算结果不为 null ，则用计算结果覆盖原有的 value 。如果原 Map 原来不包括该 key，那么该方法可能会添加一组 key-value 对。
Object computeIfPresent(Object key, BiFunction remappingFunction): 如果传给该方法的 key 参数在 Map 中对应的 value 不为 null. 该方法将使用 remappingFunction 根据原 key、 value 计算一个新的结果，如果计算结果不为 null. 则使用该结果覆盖原来的 value; 如果计算结果为 null.则删除原 key-value 对。
void forEach(BiConsumer action): 该方法是 Java 8 为 Map 新增的一个遍历 key-value 对的方法，通过该方法可以更简洁地遍历 Map 的 key-value 对。
Object getOrDefault(Object key, V defaultValue) : 获取指定 key 对应的 value 。如果该 key 不存在，则返回 defaultValue 。
Object merge(Object key, Object value, BiFunction remappingFunction): 该方法会先根据 key 参数获取该 Map 中对应的 value 。如果获取的 value 为 null. 则直接用传入的 value 覆盖原有的 value(在这种情况下，可能要添加一组 key-value 对) ;如果获取的 value 不为 null ，则使用remappingFunction 函数根据原 value 、新 value 计算一个新的结果，并用得到的结果去覆盖原有的value 。
Object putlfAbsent(Object key, Object value): 该方法会自动检测指定 key 对应的 value 是否为 null，如果该 key 对应的 value 为 null. 该方法将会用新 value 代替原来的 null 值。
Object replace(Object key, Object value): 将 Map 中指定 key 对应的 value 替换成新 value 。与传统put()方法不同的是，该方法不可能添加新的 key-value 对。如果尝试替换的 key 在原 Map 中不存在，该方法不会添加 key-value 对，而是返回 null 。
boolean replace(K key, V oldValue, V newValue): 将 Map 中指定 key-value 对的原 value 替换成新value 。如果在 Map 中找到指定的 key-value 对，则执行替换并返回 true ，否则返回 false 。
replaceAll(BíFunction function): 该力活使用 BiFunction 别原 key-value 对执行计算，并将计算结果作为该 key-value 对的 value 值。

API:java.util.Map

HashMap 和 Hashtable 实现类

=========================================================================================

图三：HashMap继承示意图

在这里插入图片描述

HashMap 和 Hashtable 都是 Map 接口的典型实现类，它们之间的关系完全类似于 ArrayList 和 Vector的关系。

Java 8 改进了 HashMap 的实现，使用 HashMap 存在 key 冲突时依然具有较好的性能。

除此之外， Hashtable 和 HashMap 存在两点典型区别。

Hashtable 是一个线程安全的 Map 实现，但 HashMap 是线程不安全的实现，所以 HashMap 比Hashtable 的性能高一点;但如果有多个线程访问同一个 Map 对象时，使用 Hashtable 实现类会更好。
Hashtable 不允许使用 null 作为 key 和 value ，如果试图把 null 值放进 Hashtable 中，将会引发 NullPointerException 异常 ; 但 HashMap 可以使用 null 作为 key 或 value 。

与 Vector 类似的是，应当尽量少用 Hashtable实现类，即使需要创建线程安全的 Map 实现类，也无须使用 Hashtable 实现类，可以通过 Collections 工具类把 HashMap 变成线程安全的。

为了成功地在 HashMap 、 Hashtable 中存储、获取对象，用作 key 的对象必须实现 hashCode()方法和 equals()方法。

与 HashSet 集合不能保证元素的顺序一样， HashMap 、 Hashtable 也不能保证其中 key-value 对的顺序。类似于 HashSet ， HashMap 、 Hashtable 判断两个 key 相等的标准也是:两个 key 通过 equals()方法比较返回 true ，两个 key 的 hashCode 值也相等。

除此之外， HashMap 、 Hashtable 中还包含一个 containsValue()方法，用于判断是否包含指定的 value 。

HashMap 、 Hashtable 判断两个 value 相等的标准更简单 : 只要两个对象通过 equals()方法比较返回 true 即可。

下面程序示范了 Hashtable 判断两个 key相等的标准和两个 value 相等的标准 :

HashtableTest.java

class A

{

int count;

public A(int count)

{

this.count = count;

}

// 根据count的值来判断两个对象是否相等。

public boolean equals(Object obj)

{

if (obj == this)

return true;

if (obj != null && obj.getClass() == A.class)

{

A a = (A)obj;

return this.count == a.count;

}

return false;

}

// 根据count来计算hashCode值。

public int hashCode()

{

return this.count;

}

class B

{

// 重写equals()方法，B对象与任何对象通过equals()方法比较都返回true

public boolean equals(Object obj)

{

return true;

}

public class HashtableTest

{

public static void main(String[] args)

{

Hashtable ht = new Hashtable();

ht.put(new A(60000) , “疯狂Java讲义”);

ht.put(new A(87563) , “轻量级Java EE企业应用实战”);

ht.put(new A(1232) , new B());

System.out.println(ht);

// 只要两个对象通过equals比较返回true，

// Hashtable就认为它们是相等的value。

// 由于Hashtable中有一个B对象，

// 它与任何对象通过equals比较都相等，所以下面输出true。

System.out.println(ht.containsValue(“测试字符串”)); // ① 输出true

// 只要两个A对象的count相等，它们通过equals比较返回true，且hashCode相等

// Hashtable即认为它们是相同的key，所以下面输出true。

System.out.println(ht.containsKey(new A(87563))); // ② 输出true

// 下面语句可以删除最后一个key-value对

ht.remove(new A(1232)); //③

System.out.println(ht);

}

值得一提的是: 虽然容器号称存储的是 Java 对象，但实际上并不会真正将 Java 对象放入容器中，只是在容器中保留这些对象的引用，而这些引用变量指向了我们要实际保存的 Java 对象。

图四：HashMap存储对象示意图

在这里插入图片描述

API:java.util.HashMap

API:java.util.Hashtable

LinkedHashMap 实现类

===================================================================================

HashSet 有一个 LinkedHashSet 子类， HashMap 也有一个 LinkedHashMap 子类 ; LinkedHashMap 也使用双向链表来维护 key-value 对的次序(其实只需要考虑、 key 的次序) ，该链表负责维护 Map 的迭代顺序，迭代顺序与 key-value 对的插入顺序保持一致。

LinkedHashMap 可以避免对 HashMap 、 Hashtable 里的 key-value 对进行排序(只要插入 key-value对时保持顺序即可)，同时又可避免使用 TreeMap 所增加的成本。

LinkedHashMap 需要维护元素的插入顺序，因此性能略低于 HashMap 的性能;但因为它以链表来维护内部顺序，所以在迭代访问 Map 里的全部元素时将有较好的性能。下面程序示范了 LinkedHashMap的功能:迭代输出 LinkedHashMap 的元素时，将会按添加 key-value 对的顺序输出 :

LinkedHashMapTest.java

public class LinkedHashMapTest

{

public static void main(String[] args)

{

LinkedHashMap scores = new LinkedHashMap();

scores.put(“语文” , 80);

scores.put(“英文” , 82);

scores.put(“数学” , 76);

// 调用forEach方法遍历scores里的所有key-value对

scores.forEach((key, value) -> System.out.println(key + “–>” + value));

}

API:java.util.LinkedHashMap

Properties 类

==============================================================================

Properties 类是 Hashtable 类的子类，该类对象在处理属性文件时特别方便 (Windows 操作平台上的ini文件就是一种属性文件)。 Properties 类可以把 Map对象和属性文件关联起来，从而可以把 Map 对象中的 key-value 对写入属性文件中，也可以把属性文件中的"属性名=属性值 "加载到 Map 对象中。由于属性文件里的属性名、属性值只能是字符串类型，所以 Properties 里的 key、value 都是字符串类型。

该类提供了如下三个方法来修改 Properties 里的 key 、 value 值 :

String getProperty(String key): 获取 Properties 中指定属性名对应的属性值，类似于 Map 的get(Object key)方法。
String getProperty(String key, String defaultValue): 该方法与前一个方法基本相似。该方法多一个功能，如果 Properties 中不存在指定的 key 时，则该方法指定默认值。
Object setProperty(String key, String value): 设置属性值，类似于 Hashtable 的 put()方法。除此之外，它还提供了两个读写属性文件的方法。
void load(InputStream inStream): 从属性文件 ( 以输入流表示)中加载 key-value 对，把加载到的key-value 对追加到 Properties 里( Properties 是 Hash table 的子类，它不保证 key-value 对之间的次序)。
void store(OutputStream out, String comments): 将 Properties 中的 key-value 对输出到指定的属性文件(以输出流表示)中。

下面程序示范了 Properties 类的用法:

PropertiesTest.java

public class PropertiesTest

{

public static void main(String[] args)

throws Exception

{

Properties props = new Properties();

// 向Properties中增加属性

props.setProperty(“username” , “yeeku”);

props.setProperty(“password” , “123456”);

// 将Properties中的key-value对保存到a.ini文件中

props.store(new FileOutputStream(“a.ini”)

, “comment line”); //①

// 新建一个Properties对象

Properties props2 = new Properties();

// 向Properties中增加属性

props2.setProperty(“gender” , “male”);

// 将a.ini文件中的key-value对追加到props2中

props2.load(new FileInputStream(“a.ini”) ); //②

System.out.println(props2);

}

API:java.util.Properties

SortedMap 接口和 TreeMap 实现类

===========================================================================================

图五：TreeMap继承示意图

在这里插入图片描述

正如 Set 接口派生出 SortedSet 子接口， SortedSet 接口有一个 TreeSet 实现类一样， Map 接口也派生出一个 SortedMap 子接口， SortedMap 接口也有一个 TreeMap 实现类。

TreeMap 就是一个红黑树数据结构，每个 key-value 对即作为红黑树的一个节点。 TreeMap 存储key-value 对(节点)时，需要根据 key 对节点进行排序。 TreeMap 可以保证所有的 key-value 对处于有序状态。

最后我们该如何学习？

1、看视频进行系统学习

这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。

另外，我自己也珍藏了好几套视频资料躺在网盘里，有需要的我也可以分享给你：