【Java数据结构】Map和Set（哈希表详解）
Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。
目录
1. Map
实例化
添加元素（put）
打印
2. Set
实例化
添加元素（add）
打印
3. 小练习
3.1 找出重复的数据（Set练习）
3.2 去重（Set练习）
3.3 统计重复数据出现的次数（Map练习）
4. LeetCode题型训练
4.1 只出现一次的数字
4.2 ⭐⭐复制带随机指针的链表
4.3 宝石与石头
4.4 坏键盘打字
4.5 前K个高频单词（难题）
1. Map
Map是一个接口类，该类没有继承自Collection，该类中存储的是结构的键值对，并且K一定是唯一的，不 能重复。
实例化
Map map = new HashMap<>();
HashMap map2 = new HashMap<>(); 添加元素（put）
map.put("猴哥","孙悟空");
map.put("八戒","猪八戒");
map.put("悟净","沙僧");打印
import java.util.Set;
//1、直接打印法
System.out.println(map);
//Set打包后再遍历打印法
Set> set = map.entrySet();
for (Map.Entry entry : set) {
System.out.println("key："+entry.getKey()+" Value:"+entry.getValue());
} 2. Set
Set是一个集合类。Set与Map主要的不同有两点：Set是继承自Collection的接口类，Set中只存储了Key。
实例化
import java.util.Set;
Set set = new HashSet<>();
HashSet set1 = new HashSet<>(); 添加元素（add）
和Map一样也是无序的！
set1.add(1);
set1.add(2);
set1.add(3);
set1.add(4);
System.out.println(set1);
set.add("hello");
set.add("hello1");
set.add("hello2");
set.add("hello3");
set.add("hello4");
System.out.println(set);打印
//1、直接打印
System.out.println(set);
//2、迭代器(不可以遍历Map)
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
} 
3. 小练习
- 从10W个数据中，找出第一个重复的数据
- 去除10W个数据当中，重复的数据（去重）
- 统计重复的数据出现的次数
3.1 找出重复的数据（Set练习）
思路：使用set.contains( ) 判断是否已存在于set中
//判断是否存在set.contains()
public static void main(String[] args) {
int[] array = new int[10];
Random rand = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = rand.nextInt(10);
}
System.out.println(Arrays.toString(array));
HashSet set = new HashSet<>();
for (int i = 0; i < array.length; i++) {
if (set.contains(array[i])) {
System.out.println(array[i]);
break;
}
set.add(array[i]);
}
System.out.println(set);
} 3.2 去重（Set练习）
//判断是否存在set.contains()
public static void main(String[] args) {
int[] array = new int[10];
Random rand = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = rand.nextInt(10);
}
System.out.println(Arrays.toString(array));
HashSet set = new HashSet<>();
for (int i = 0; i < array.length; i++) {
set.add(array[i]);
}
System.out.println(set);
} 3.3 统计重复数据出现的次数（Map练习）
使用map.contains 和 map.get() == null 都可以用来判断是否已经存在。
public class Test {
public static void main(String[] args) {
int[] array = new int[10];
Random rand = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = rand.nextInt(5);
}
HashMap map = new HashMap<>();
//判断数组的数据 是否再map中 没有就是1，有的话就value+1
for (int i = 0; i < array.length; i++) {
/*if (map.containsKey(array[i])) {
int val = map.get(array[i]);
map.put(array[i], val+1);
} else {
map.put(array[i], 1);
}*/
if (map.get(array[i] == null)) {
map.put(array[i],1);
} else {
int val = map.get(array[i]);
map.put(array[i],val+1);
}
}
//打印
for (Map.Entry entry: map.entrySet()) {
System.out.println("关键字 "+entry.getKey()+" 次数"+entry.getValue());
}
}
} 4. LeetCode题型训练
4.1 只出现一次的数字
136. 只出现一次的数字 - 力扣（LeetCode） (leetcode-cn.com)
常规最优解题法（异或）：
class Solution {
public int singleNumber(int[] nums) {
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum ^= nums[i];
}
return sum;
}
}使用Set：
class Solution {
public int singleNumber(int[] nums) {
HashSet set = new HashSet<>();
for (int val : nums) {
if (set.contains(val)) {
set.remove(val);
} else {
set.add(val);
}
}
for (int val : nums) {
if (set.contains(val)) {
return val;
}
}
return -1;
}
} 4.2 ⭐⭐复制带随机指针的链表
138. 复制带随机指针的链表 - 力扣（LeetCode） (leetcode-cn.com)
class Solution {
public Node copyRandomList(Node head) {
HashMap map = new HashMap<>();
Node cur = head;
while (cur != null) {
Node node = new Node(cur.val);
map.put(cur,node);
cur = cur.next;
}
cur = head;
while (cur != null) {
map.get(cur).next = map.get(cur.next);
map.get(cur).random = map.get(cur.random);
cur = cur.next;
}
return map.get(head);
}
} 4.3 宝石与石头
771. 宝石与石头 - 力扣（LeetCode） (leetcode-cn.com)
class Solution {
public int numJewelsInStones(String jewels, String stones) {
HashSet set = new HashSet<>();
for (int i = 0; i < jewels.length(); i++) {
char ch = jewels.charAt(i);
set.add(ch);
}
int count = 0;
for (int i = 0; i < stones.length(); i++) {
char ch = stones.charAt(i);
if (set.contains(ch)) {
count++;
}
}
return count;
}
} 4.4 坏键盘打字
旧键盘 (20)__牛客网 (nowcoder.com)
思路：
- 把str1当中的每个字符，转换成大写的，然后放到集合当中（char[ ] ch=str1.toUpperCase().toCharArray() ;
- 遍历str1，每个字符仍然要是大写，和集合当中的元素去比较，没有就输出
import java.util.*;
public class Main {
public static void func(String str1, String str2) {
HashSet set = new HashSet<>();
//把打印出来的东西放进set
for (char ch : str2.toUpperCase().toCharArray()) {
set.add(ch);
}
for (char ch : str1.toUpperCase().toCharArray()) {
if (!set.contains(ch)) {
System.out.print(ch);
set.add(ch);
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str1 = sc.nextLine();
String str2 = sc.nextLine();
func(str1,str2);
}
} 4.5 前K个高频单词（难题）
692. 前K个高频单词 - 力扣（LeetCode） (leetcode-cn.com)
思路：
- 统计字符串当中每个单词出现的次数（HashMap）
- 定义一个小根堆，设置其比较方式是根据每个单词出现的次数进行比较
- 开始遍历map，拿到每一个entry
class Solution {
public List topKFrequent(String[] words, int k) {
//1、统计单词出现的次数 存放在map当中
HashMap map = new HashMap<>();
for (String s : words) {
if (map.get(s) == null) {
map.put(s,1);
} else {
int val = map.get(s);//原来这个单词出现的次数
map.put(s,val+1);
}
}
//定义一个小根堆，因为我们找的是出现频率高的，所以小根堆的比较方式是根据每个单词出现的次数进行比较
PriorityQueue> minHeap = new PriorityQueue<>(new Comparator>() {
@Override
public int compare(Map.Entry o1, Map.Entry o2) {
if(o1.getValue().compareTo(o2.getValue()) == 0) {
return o2.getKey().compareTo(o1.getKey());
}
return o1.getValue()-o2.getValue();
}
});
//3、开始遍历map，拿到每一个entry
for (Map.Entry entry : map.entrySet()) {
if (minHeap.size() < k ) {
minHeap.offer(entry);
} else {
Map.Entry top = minHeap.peek();
if (top != null) {
if (top.getValue().compareTo(entry.getValue()) == 0) {
if (entry.getKey().compareTo(top.getKey()) < 0) {
minHeap.poll();
minHeap.offer(entry);
}
} else {
if (entry.getValue().compareTo(top.getValue()) > 0) {
minHeap.poll();
minHeap.offer(entry);
}
}
}
}
}
//4、小堆弹出信息
List ret = new ArrayList<>();
for (int i = 0; i < k; i++) {
Map.Entry top = minHeap.poll();
if (top != null) {
ret.add(top.getKey());
}
}
Collections.reverse(ret);
return ret;
}
}