Map和Set小总结【温习】

龙洋静

已于 2023-11-27 10:28:27 修改

阅读量1k

点赞数 19

分类专栏： Java 文章标签： java 开发语言

于 2023-11-26 19:19:22 首次发布

本文链接：https://blog.csdn.net/LYJbao/article/details/134631232

版权

Java 专栏收录该内容

37 篇文章 3 订阅

订阅专栏

一、概念与模型

1.概念：

Map 和 set 是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的搜索方式有： ①直接遍历，时间复杂度为O(N) ，元素如果比较多效率会非常慢 ②二分查找，时间复杂度为O(logN),但搜索前必须要求序列是有序的。上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如： ①根据姓名查询考试成绩 ②通讯录，即根据姓名查询联系方式 ③不重复集合，即需要先搜索关键字是否已经在集合中，可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本博客总结的Map 和 Set 是一种适合动态查找的集合容器。

2.模型：

        一般把搜索的数据称为关键字（ Key ），和关键字对应的称为值（ Value ），将其称之为 Key-value 的键值对，所以模型会有两种：
        （1）纯 key 模型，如：有一个英文词典，快速查找一个单词是否在词典中快速查找某个名字在不在通讯录中
        （2）Key-Value 模型，如： ①统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：< 单词，单词出现的次数 > ②梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号。
        而Map 中存储的就是 key-value 的键值对， Set 中只存储了 Key 。

二、Map的使用

1.Map 是一个接口类，该类没有继承自 Collection ，该类中存储的是 <K,V> 结构的键值对，并且 K 一定是唯一的，不能重复。
2. 关于 Map.Entry<K, V> 的说明：

3.Map 的常用方法说明：

说明：

Map 是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类 TreeMap 或者 HashMap
Map 中存放键值对的 Key 是唯一的， value 是可以重复的
在TreeMap中插入键值对时，key 不能为空，否则就会抛 NullPointerException 异常，但是 value 可以为空，但是HashMap两个都可以为空
Map 中的 Key 可以全部分离出来，存储到 Set 中来进行访问 ( 因为 Key 不能重复 ) 。
Map 中的 value 可以全部分离出来，存储在 Collection 的任何一个子集合中 (value 可能有重复 ) 。
Map 中键值对的 Key 不能直接修改， value 可以修改，如果要修改 key ，只能先将该 key 删除掉，然后再来进行重新插入。

TreeMap 和 HashMap 的区别：

三、Set的说明

Set 与 Map 主要的不同有两点： Set 是继承自 Collection 的接口类， Set 中只存储了 Key
1.一些常用的方法：

（1）Set 是继承自 Collection 的一个接口类
（2）Set 中只存储了 key ，并且要求 key 一定要唯一
（3）Set 的底层是使用 Map 来实现的，其使用 key 与 Object 的一个默认对象作为键值对插入到 Map 中的
（4）Set 最大的功能就是对集合中的元素进行去重
（5）实现 Set 接口的常用类有 TreeSet 和 HashSet ，还有一个 LinkedHashSet ， LinkedHashSet 是在 HashSet 的基础上维护了一个双向链表来记录元素的插入次序。
（6）Set 中的 Key 不能修改，如果要修改，先将原来的删除掉，然后再重新插入
（7）Set 中不能插入 null 的 key 。
（8）TreeSet 和 HashSet 的区别：

一些小练习

1.给定10W个数据，统计每个数据出现的次数

public class TestDemo {
    public static Map<Integer,Integer> func(int[] arr){
        Map<Integer,Integer> map = new HashMap<>();
        for (int x:arr) {
            if(map.get(x) == null){
                map.put(x,1);
            }else{
                int val = map.get(x);
                map.put(x,val+1);
            }
        }
        return map;
    }
    public static void main(String[] args) {
        int[] arr = new int[10_0000];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(1000);
        }
        Map<Integer,Integer> map = func(arr);
        System.out.println(map);
    }
}

2.将10W个数据中的数据去重

把数据放到Set即可

public static Set<Integer> func2(int[] arr){
    HashSet<Integer> set = new HashSet<>();
    for (int x:arr) {
        set.add(x);
    }
    return set;
}

3.从10W个数据中找到第一个重复的数据

把数据放到Set中，放之前检查一下，Set中是不是已经有了

public static int func3(int[] arr){
    HashSet<Integer> set = new HashSet<>();
    for (int x:arr) {
        if(set.contains(x)){
             return x;
        }
        set.add(x);
   }
        return -1;
}

四、哈希表

1.概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为 O(N) ，平衡树中为树的高度，即 O(logn )，搜索的效率取决于搜索过程中元素的比较次数。理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素

根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

搜索元素

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。

该方式即为哈希 ( 散列 ) 方法，哈希方法中使用的转换函数称为哈希 ( 散列 ) 函数，构造出来的结构称为哈希表 (Hash Table)( 或者称散列表 )

2.冲突

2.1、概念

对于两个数据元素的关键字和 (i != j) ，有 != ，但有： Hash( ) == Hash( ) ，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为 “ 同义词 ” 。

注意：由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。

2.2、冲突-->避免

引起哈希冲突的其中一个原因可能是： 哈希函数设计不够合理 。哈希函数设计原则：

哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
哈希函数计算出来的地址能均匀分布在整个空间中
哈希函数应该比较简单

常见的哈希函数：

直接定制法（常用）：取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀缺点：需要事先知道关键字的分布情况使用场景：适合查找比较小且连续的情况
除留余数法 (常用) ：设散列表中允许的地址数为 m ，取一个不大于 m ，但最接近或者等于 m 的质数 p 作为除数，按照哈希函数： Hash(key) = key% p(p<=m), 将关键码转换成哈希地址
平方取中法：假设关键字为 1234 ，对它平方就是 1522756 ，抽取中间的 3 位 227 作为哈希地址；再比如关键字为 4321 ，对它平方就是18671041 ，抽取中间的 3 位 671( 或 710) 作为哈希地址平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
折叠法：将关键字从左到右分割成位数相等的几部分 ( 最后一部分位数可以短些 ) ，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
随机数法：选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key), 其中 random 为随机数函数。通常应用于关键字长度不等时采用此法
数学分析法：
设有 n 个 d 位数，每一位可能有 r 种不同的符号，这 r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。如：假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前 7 位都是相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转 ( 如1234改成 4321) 、右环位移 ( 如 1234 改成 4123) 、左环移位、前两数与后两数叠加 ( 如 1234 改成 12+34=46) 等方法。数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

降低冲突率的另一个方法： 负载因子调节【负载因子α=存储散列表的元素个数/散列表的长度】

α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中元素的个数”成正比，所以α越大，表明填入表中的元素越多，产生冲突的可能性越大；反之，α越小，表明填入表中的元素越少，产生冲突的可能性越少。实际上，散列表的平均查找长度是α的函数，只是不同处理冲突的方法有不同的函数。对于开放定址法，α是特别重要的因素，应严格限制在0.7~0.8以下，超过0.8，查表时的CPU缓存不命中按照指数曲线上升。因此，一些采用开放定址法的hash库，如Java的系统限制了α为0.75，超过此值将resize散列表

所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。

已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

2.3、冲突-->解决

解决哈希冲突 两种常见的方法是： 闭散列 和 开散列

（1）闭散列

也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把 key 存放到冲突位置中的 “ 下一个 ” 空位置中去。
如何寻找下一个空位置？

① 线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。插入：

通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4；如果直接删除掉， 44 查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找

②二次探测：
二次探测为了避免线性探测的问题，找下一个空位置的方法为：Hi= (H0+i^2)% m, 或者：Hi= (H0+i^2)% m。其中：i = 1,2,3…，H0是通过散列函数Hash(x) 对元素的关键码 key 进行计算得到的位置，m是表的大小。对于上面中如果要插入 44 ，产生冲突，使用解决后的情况为

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷

（2）开散列

开散列法又叫链地址法 ( 开链法 ) ，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

代码实现：

public class HashBuck {
    static class Node{
        public int key;
        public int val;
        public Node next;
 
        public Node(int key, int val){
            this.key = key;
            this.val = val;
        }
    }
    public Node[] arr;
    public int usedSize;
    public static final double DEFAULT_LOADFactor = 0.75;
 
    public HashBuck(){
        this.arr = new Node[10];
    }
 
    public void put(int key, int val){
        //找到key所在的位置
        int index = key % this.arr.length;
        //遍历下标的链表，看看是不是有相同的key,如果有，要更新val
        Node cur = arr[index];
        while(cur != null){
            if(cur.key == key){
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        //没有key这个元素，头插法插入
        Node node = new Node(key,val);
        node.next = arr[index];
        arr[index] = node;
        this.usedSize++;
        //插入元素成功后，检查当前散列表的负载因子
        if(loadFactor() > DEFAULT_LOADFactor){
            resize();//扩容----->不是简单的把数组扩大，数组里面的每个链表的每个元素必须重新进行哈希
                     //14%10=4   14%20=14
        }
    }
 
    private void resize(){
        Node[] newArr = new Node[arr.length*2];
        for(int i = 0; i < this.arr.length; i++){
            Node cur = arr[i];
            while(cur != null){
                int index = cur.key % newArr.length;//获取新的下标
                //把cur这个节点，以头插或者尾插的方式插入到新的数组对应下标的链表当中
                Node curNext = cur.next;
                cur.next = newArr[index];//先绑定前面
                newArr[index] = cur;//再绑定后面
                cur = curNext;
            }
        }
        arr = newArr;
    }
 
    private double loadFactor(){
        return 1.0 * usedSize / this.arr.length;
    }
 
    public int get(int key){
        //找到key所在的位置
        int index = key % this.arr.length;
        //遍历下标的链表，看看是不是有相同的key,如果有，要更新val
        Node cur = arr[index];
        while(cur != null){
            if(cur.key == key){
                return cur.key;
            }
            cur = cur.next;
        }
        return -1;
    }
}

代码实现改进：

import java.util.HashMap;
import java.util.Objects;
 
class Person{
    public String ID;
 
    public Person(String ID){
        this.ID = ID;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(ID, person.ID);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(ID);
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "ID='" + ID + '\'' +
                '}';
    }
}
public class HashBuck2<K,V> {
    static class Node<K,V>{
        public K key;
        public V val;
        public Node<K,V> next;
 
        public Node(K key, V val){
            this.key = key;
            this.val = val;
        }
    }
    public Node<K,V>[] arr = (Node<K,V>[])new Node[10];
    public int usedSize;
 
    public void put(K key, V val){
        int hash = key.hashCode();//hashcode()寻找位置
        int index = hash % arr.length;
        Node<K,V> cur = arr[index];
        while(cur != null){
            if(cur.key.equals(key)){//equals()负责查看有没有一样的元素
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        Node<K,V> node = new Node(key,val);
        node.next = arr[index];
        arr[index] = node;
        this.usedSize++;
    }
    //hashcode()一样，equals()不一定一样；equals()一样，hashcode()一定一样
 
    public V get(K key){
        int hash = key.hashCode();//hashcode()寻找位置
        int index = hash % arr.length;
        Node<K,V> cur = arr[index];
        while(cur != null){
            if(cur.key.equals(key)){//equals()负责查看有没有一样的元素
                return cur.val;
            }
            cur = cur.next;
        }
        return null;
    }
 
    public static void main(String[] args) {
        Person person1 = new Person("123");
        Person person2 = new Person("123");
 
        HashBuck2<Person,String> hashBuck2 = new HashBuck2();
        hashBuck2.put(person1,"abc");
 
        System.out.println(hashBuck2.get(person2));
 
    }
}

运行结果：abc