Map 和 Set 【数据结构】

• Map 中的 key 可以全部分离出来，存储到 Set 中来进行访问 (因为 key 不能重复)

• Map 中的 value 可以全部分离出来，存储在 Collection 的任何一个子集合中 (value可能有重复)

• Map 中键值对的 key 不能直接修改，value 可以修改，如果要修改 key，只能先将该 key 删除掉，然后再进行重新插入

• HashMap 和 TreeMap 的区别

| Map底层结构 | TreeMap | HashMap |

| — | — | — |

| 底层结构 | 红黑树 | 哈希桶 |

| 插入 / 删除 / 查找时间复杂度 | O(logN) | O(1) |

| 是否有序 | 关于 key 有序 | 无序 |

| 线程是否安全 | 不安全 | 不安全 |

| 插入 / 删除 / 查找区别 | 需要进行元素比较 | 通过哈希函数计算哈希地址 |

| 比较与重写 | key 必须能够比较，否则会抛出 ClassCastException 异常 | 自定义类型需要重写 equals 和 hashCode 方法 |

| 应用场景 | 需要 key 有序场景下 | key 是否有序不关心，需要更高的时间性能 |

Set 的使用

---

Set与Map主要的不同：

• Set 是继承自 Collection 的接口类

• Set 中只存储了 key

常见方法：

| 方法 | 说明 |

| — | — |

| boolean add(E e) | 添加元素，但重复元素不会被添加成功 |

| void clear( ) | 清空集合 |

| boolean contains(Object o) | 判断 o 是否在集合中 |

| Iterator iterator( ) | 返回迭代器 |

| boolean remove(Object o) | 删除集合中的 o |

| int size( ) | 返回set中元素的个数 |

| boolean isEmpty( ) | 检测 set 是否为空，空返回 true，否则返回 false |

| Object[] toArray( ) | 将 set 中的元素转换为数组返回 |

| boolean containsAll(Collection<?> c) | 集合 c 中的元素是否在 set 中全部存在，是返回 true，否则返回 false |

| boolean addAll(Collection<? extends E> c) | 将集合 c 中的元素添加到 set 中，可以达到去重的效果 |

HashSet 代码示例：

public static void main(String[] args) {

//1.实例化 Set

Set set = new HashSet<>();

//2.插入元素 : add

set.add(“hello”);

set.add(“Java”);

set.add(“Cpp”);

// 插入null

set.add(null);

//3.判断某个值是否存在

System.out.println("Java: " + set.contains(“Java”));

System.out.println("Python: " + set.contains(“Python”));

System.out.println("Cpp: " + set.contains(“Cpp”));

System.out.println("null: " + set.contains(“null”));

//4.删除某个值

System.out.println(“删除Cpp…”);

set.remove(“Cpp”);

System.out.println("Cpp: " + set.contains(“Cpp”));

//删除null

System.out.println(“删除null…”);

System.out.println("null: " + set.contains(null));

//5.打印Set

// a) 直接打印

System.out.println(set);

// b) 循环遍历,使用迭代器

// 迭代器的泛型参数 要和 集合类中保存的元素参数类型一致

// 集合类内部自己实现自己版本的迭代器,不同的集合类 内部的迭代器类型不同，迭代方式也不同

System.out.print(“使用迭代器打印：”);

Iterator iterator = set.iterator();

while (iterator.hasNext()){

String next = iterator.next();

System.out.print(next + " ");

}

}

输出结果：

TreeSet 代码示例：

public static void main(String[] args) {

//1.实例化 Set

Set set = new TreeSet<>();

//2.插入元素

set.add(“Hello”);

set.add(“Java”);

set.add(“Cpp”);

// 不能插入null，会抛出 空指针异常

// set.add(null);

//3.判断某个值是否存在

System.out.println("Java: " + set.contains(“Java”));

System.out.println("Python: " + set.contains(“Python”));

System.out.println("Cpp: " + set.contains(“Cpp”));

// contains(key): key为null，抛出空指针异常

// System.out.println("null: " + set.contains(null));

//4.删除某个值

System.out.println(“删除Cpp…”);

set.remove(“Cpp”);

System.out.println("Cpp: " + set.contains(“Cpp”));

//删除null

System.out.println(“删除null…”);

// remove(key): key为null，抛出空指针异常

// set.remove(null);

// System.out.println("null: " + set.contains(null));

//5.打印 set

// a) 直接打印

System.out.println(set);

// b) 迭代器打印

System.out.print(“使用迭代器打印：”);

Iterator iterator = set.iterator();

while (iterator.hasNext()){

String next = iterator.next();

System.out.print(next + " ");

}

}

输出结果：

注意事项：

• Set 是继承自 Collection 的一个接口类

• Set 中只存储了 key，key 是唯一的，不能重复

• Set 最大的功能就是对集合中的元素进行去重

• Set 中的 Key 不能修改，如果要修改，先将原来的删除掉，然后再重新插入

• TreeSet 和 HashSet 的区别

| Set | TreeSet | HashSet |

| — | — | — |

| 底层结构 | 红黑树 | 哈希桶 |

| 插入 / 删除 / 查找时间复杂度 | O(logN) | O(1) |

| 是否有序 | 关于 key 有序 | 不一定有序 |

| 线程是否安全 | 不安全 | 不安全 |

| 插入 / 删除 / 查找区别 | 按照红黑树的特性来进行插入和删除 | 1. 先计算 key 哈希地址；2. 然后进行插入和删除 |

| 比较与重写 | key 必须能够比较，否则会抛出 ClassCastException 异常 | 自定义类型需要重写 equals 和 hashCode 方法 |

| 应用场景 | 需要 key 有序场景下 | key是否有序不关心，需要更高的时间性能 |

题目练习

---

只出现 1 次的数字

题目： 在线OJ

思考：

方法一： 通过 Map 统计每个数字出现的次数，再遍历 Map 找到那个只出现一次的数字

• 创建 Map<Integer，Integer>，key：当前出现的数字；value：该数字出现次数

• 遍历统计次数即可~

方法二： 按位异或 A ^ B ^ A = B；A ^ 0 = A，异或规则，相同为0，相异为1

代码实现：

• 方法1

public int singleNumber(int[] nums) {

// key : 当前数字

// value : 数字出现次数

Map<Integer,Integer> map = new HashMap<>();

for (int x : nums) {

Integer value = map.get(x);

// 当前数字在 map 中不存在，新增一个键值对

if(value == null){

map.put(x,1);

}

//这个数字已经存在了

else{

map.put(x,value + 1);

}

}

// 遍历 map ，找到出现次数为1的数

for (Map.Entry<Integer,Integer> entry : map.entrySet()) {

// getValue 得到的是一个 Integer 包装类

// 使用 equals，相当于对 1 自动装箱

// 使用 == ，相当于对 Integer 自动拆箱

if(entry.getValue().equals(1)){

return entry.getKey();

}

}

//没找到

return 0;

}

• 方法2

public int singleNumber(int[] nums) {

int result = 0;

for (int x : nums) {

result ^= x;

}

return result;

}

复制带随机指针的链表

题目： 在线OJ

思考：

• 创建一个 Map <Node，Node>，key：旧链表的节点；value：新链表的节点(旧链表对应节点的拷贝)

• Map 结构创建好了之后，遍历旧链表，取出节点在 Map 中找到对应的 value

例：新node1.next = map.get (旧node1.next)；

新node1.random = map.get (旧node1.random)；

代码实现：

public Node copyRandomList(Node head) {

//1.创建 map

Map<Node,Node> map = new HashMap<>();

//2.遍历旧链表，把旧链表的每个节点 依次插入到map中

// key: 旧链表节点

// value: 新链表节点

for (Node cur = head;cur != null;cur = cur.next){

map.put(cur,new Node(cur.val));

}

// 再次遍历链表，修改新链表节点中的 next 和 random

for (Node cur = head;cur != null;cur = cur.next){

// 先从 map 中找到 该 cur对应的新链表对应的节点

Node newCur = map.get(cur);

newCur.next = map.get(cur.next);

newCur.random = map.get(cur.random);

}

// 返回新链表的头节点

return map.get(head);

}

宝石和石头

题目： 在线OJ

思考：

• 遍历 J，把所有宝石放到一个 set 里

• 遍历 S，和 set 中元素比较即可

代码实现：

public int numJewelsInStones(String jewels, String stones) {

// 先遍历J，把所有宝石类型加到一个 set 里

Set set = new HashSet<>();

for (char c : jewels.toCharArray()) {

set.add©;

}

// 遍历 S，和set 中元素比较

int ret = 0;

for (char c : stones.toCharArray()) {

if(set.contains©){

ret++;

}

}

return ret;

}

旧键盘打字

题目： 在线OJ

旧键盘上坏了几个键，于是在敲一段文字的时候，对应的字符就不会出现。现在给出应该输入的一段文字、以及实际被输入的文字，请你列出肯定坏掉的那些键

---

输入描述：

输入在2行中分别给出应该输入的文字、以及实际被输入的文字。每段文字是不超过80个字符的串，由字母A-Z（包括大、小写）、数字0-9、

以及下划线“_”（代表空格）组成。题目保证2个字符串均非空

---

输出描述：

按照发现顺序，在一行中输出坏掉的键。其中英文字母只输出大写，每个坏键只输出一次。题目保证至少有1个坏键

思考：

坏掉的键，即：按下键，没有输出

给出一个预期输出的字符串，再给出一个实际输出的字符串

找到那些预期要输出，但实际没输出的字符，这样的字符就是坏掉的键

键盘上某个键坏了，则其大小写字母均不会输出，需要把 A 和 a当成同一种情况

代码实现：

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

//循环读取两个字符串

// 字符串1: 预期输出内容; 字符串2: 实际输出内容

while (scan.hasNext()){

String expected = scan.next();

String actual = scan.next();

// 把输入的字符串全部转换成大写字母

expected = expected.toUpperCase();

actual = actual.toUpperCase();

// 创建一个set, 存储实际输出的每个字符

Set actualSet = new HashSet<>();

for (int i = 0; i < actual.length(); i++) {

// set中的元素 不能重复，若add时，发现这个元素已经存在，add操作就会失败，

// 但不会有任何影响，不会抛出异常，也不会影响元素原来的内容

actualSet.add(actual.charAt(i));

}

// 存放坏的键的set

Set brokenKeySet = new HashSet<>();

// 遍历预期输出内容,看是否匹配即可

for (int i = 0;i < expected.length();i++){

char c = expected.charAt(i);

//当前字符被输出，该键没坏

if(actualSet.contains©){

continue;

}

//没被输出，就是坏的键

// [坏的键],预期字符串中可能多次出现坏的键,但最后输出结果 只输出一次

// 需要去重操作

if(brokenKeySet.contains©){

continue;

}

System.out.print©;

brokenKeySet.add©;

}

}

}

前 K 个高频单词

题目： 在线OJ

思考：

• 先统计数组中每个单词出现的次数，使用 Map

• 把键值对组织到一个 ArrayList 中

• 按照题目要求降序排序(出现次数 + 字典序)

• 取前 K 个元素即可

代码实现：

最后

按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。

学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。

“道路是曲折的，前途是光明的！”

©;

}

}

}

前 K 个高频单词

题目： 在线OJ

思考：

• 先统计数组中每个单词出现的次数，使用 Map

• 把键值对组织到一个 ArrayList 中

• 按照题目要求降序排序(出现次数 + 字典序)

• 取前 K 个元素即可

代码实现：

最后

按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。

学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。

“道路是曲折的，前途是光明的！”

[外链图片转存中…(img-kgpGdpol-1719282590162)]

[外链图片转存中…(img-zw6vAbtV-1719282590163)]