【JAVA数据结构】哈希表-HashSet and HashMap

已于 2023-06-04 08:55:49 修改
阅读量325 收藏 2
点赞数 2
分类专栏： JAVA数据结构 文章标签： 数据结构 java 散列表
于 2023-02-24 14:20:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Carefree_State/article/details/129199694
版权

文章目录

JAVA数据结构 & 哈希表 -HashSet and HashMap

引例

  • 在讲这个部分之前，请试着去做一下下面这道题。

  • 题：给定一串序列（char[] (小写字母)），要求你将其排序并且不能出现重复也不能有一个缺席。

    • 没错，我们可以这么做：

    • char[] arr = new char[26];

//假设ch 为某个小写字母;

arr[ch - 'a']++;

    • 我们可以讲这个字母减掉’ ‘ a ’（即 97），这样a对应0，b对应1…

    • 这样我们就只需要遍历一遍数组，只要不是’\u0000’(默认值),就打印or其他。

      • 并且也可以快速知道对应字母的个数。

    • 这样的思想就是“哈希思想”，把一个元素以特定的方法放进数组里，只要知道这个方法，就可以快速查找并且快速发现重复…

  • Set和Map的最大用处就是查找！

    • 哈希的时间复杂度甚至达到了O(1)！
      • 因为根据下标来找，太快了！

1. 哈希方法导致的冲突

  • 细心的同学可能发现了，用同一个哈希方法的话，避免不了两个元素放在了同一个位置去了，那么我们就需要避免和解决。

1.1 冲突的避免（从整体减少冲突的次数）

  • 这里要用到一个 负载因子常量的概念（其他地方可能有其他的说法）
  • 这个负载因子就是哈希表中【已经放入的元素的个数 / 表最大容量】的最大值

一些实验数据事实表明：

  • 哈希表越满越容易冲突

    • 呈现出S型趋势
    • 在这里插入图片描述

  • 设计：

    • 只需要让实际的负载因子时刻小于这个最大值，一旦大于等于这个最大值的时候，就让数组扩容。
    • 也面临了另一个大问题，就是扩容后，需要重新将每个元素按照原本的哈希方法放进哈希表。
  • public static final double Load_FACTOR = 0.75;//一直处于七五分满

1.2 冲突的解决

1.2.1 闭散列
  • 散列这个说法一些书籍仍在使用【哈希表的意思】
  • 那么闭散列就是在顺序表内部解决这个问题
    • 至于用顺序表是因为下标访问快
  1. 线性探测法
    • 发现用哈希方法解析后的下标，已经被占用，那么从左往右探测，第一个空的就可以放上去
      • 缺点很大：放的效率很低，取的时候效率也低，要找的那个位置不是我们要的数据，那么就要“线性探测”从左往右遍历找我们的数据。
      • 并且我们很难去区分这个位置是否有元素，比如int[] 可能值就是0，引用类型也可能值就是null，怎么就能说明那个位置空了呢？
      • 很容易达到负载值而需要重新扩容
    • 这个方法很少用，最多出道题恶心人。
      • 例如问，按照线性探测法找，需要多少步？

在这里插入图片描述

  1. 二次探测法

  • 本质上跟【线性探测法】的思路是一致的，放在顺序表的其他空的位置。

  • 但是这个方法是按照一个规律去实现的

    • Hi = (H0 + i2) % m【m为表的大小，H代表哈希值(后面会讲)】
    • Hi = (H0 - i2) % m【或者是这种】

  • 【i】就是“跳跃的次数”，即第一次发现该位置有人，跳一次，此时 i为1

    • 跳一次后发现位置还是有元素，再次跳一次，此时 i为2
    • 注意：放置的时候发现没有元素，即 i为0

      • 如下图所示（e代表元素element）：

      • 在这里插入图片描述

      • 在这里插入图片描述

  • 这种方法是线性探测法的优化，加快了放置查找的速度

    • 其他缺点依旧一个不落的继承
1.2.2 开散列（哈希桶）

  • 也就是在顺序表“外”

  • 在这里插入图片描述

  • 如图所示，让数组的类型为“链表的节点”，遇到该位置已经被占用，就头插进去就好

    • 用带头+尾插的技巧也是完全可以的，因为插入的时候都是要检测是否重复的，自然到达链尾很容易

  • 有些地方用二叉搜索树，甚至高度平衡的二叉树【即红黑树】

  • 如下图所示：

  • 在这里插入图片描述

  • 是否是就很像一个一个的“桶”

    • 所以才叫哈希桶

2. 基础简单的HashSet的模拟

  • 用简单的 int(基本数据类型)
  • 如下图的大概模板
    • 属性：
      • 节点数组
      • 已存放元素个数
      • 负载因子最大值
    • 方法：
      • 构造方法
      • 放置方法（重复则覆盖）
      • 扩容重塑方法
      • 计算负载因子方法
      • 获取key键方法（这里可以认为是判断是否存在）
        • 这里如果是Map，则对应返回的应该是键值对key对应的value值
public class HashBuck {//哈希桶法

    static class Node {

    }

    public Node[] array;
    public int useSize;
    public static final double Load_FACTOR = 0.75;//"全局"常数



    public HashBuck() {
        array = new  Node[10];
    }
    
    public void put(int key) {
        
    }

    private void resize() {
        
    }

    private double calculateLoadFactor() {
        
    }
    public boolean get(int key) {
        
    }
}

2.1 属性

2.1.1 节点
//静态内部类
static class Node {
    
    public int key;
    public Node next;

    public Node(int key) {
        this.key = key;
    }
}

public Node[] array;
2.1.2 已存放元素个数以及实际负载因子
public int useSize;
public static final double Load_FACTOR = 0.75;//"全局"常数

2.2 方法

2.2.1 构造方法
public HashBuck() {
    array = new  Node[10];//默认大小为10
}
2.2.2 放置方法
  • 哈希方法我并没有直接做一个方法出来，一般就是一条表达式而已
  • 这里是 int index = key % array.length;【取模法是很常见的】
public void put(int key) {
    int index = key % array.length;
    Node cur = array[index];
    
    //检测
    while(cur != null) {
        if(cur.key == key) {
            return;
        }else {
            cur = cur.next;
        }
    }
    
    //头插
    Node newOne = new Node(key);
    newOne.next = array[index];
    array[index] = newOne;
    
    //已存放元素+1，并且计算是否超过负载因子最大值，若超过，则扩容重塑
    useSize++;
    if(calculateLoadFactor() > Load_FACTOR) {
        resize();
    }
}
2.2.3 计算负载因子方法
private double calculateLoadFactor() {
    return (double) useSize / array.length;
}
2.2.4 扩容重塑方法
  • 只需要遍历节点数组【哈希表】，null一定代表没有数据
    • 不是null的就将该链表遍历一遍，每一个键值重新放置
      • 这里拿一个新的数组放的原因是，重新放置可能会放在前面也可能放置到后面，那么这个值等一下可能又会被遍历到。
    private void resize() {
        //扩容两倍，当然可以其他倍数（系统为1.5倍，随后细说）
        Node[] newArr = new Node[array.length * 2];
        
        
        //重塑
        for (int i = 0; i < array.length; i++) {
            while(array[i] != null) {
                int index = array[i].key % newArr.length;
                Node cur = newArr[index];
                Node newOne = new Node(array[i].key);
                if(cur == null) {
                    newArr[index] = newOne;
                }else {
//  尾插法              while(cur.next != null) {
//                        cur = cur.next;
//                    }
//                    cur.next = new Node(array[i].key, array[i].val);
                    newOne.next = cur;
                    newArr[index] = newOne;
                }
                array[i] = array[i].next;
            }
        }
        
        //指向新的节点数组
        array = newArr;
    }
2.2.5 获取key键方法
public boolean get(int key) {
    int index = key % array.length;
    Node cur = array[index];
    while(cur != null) {
        if(cur.key == key) {
            return true;
        }
        cur = cur.next;
    }
    return false;
}
  • 我在这里就不测试了

3. HashMap的模拟

  • 在【2】的基础下，只需要让节点多一个成员，则多出一层“映射关系”，这就是Map映射
  • 如下代码，大致与上面相似
  • key为自变量，不能重复，重复则覆盖（value值更改）
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[] array;
    public int useSize;
    public static final double Load_FACTOR = 0.75;//"全局"常数



    public HashBuck() {
        array = new  Node[10];
    }
    public void put(int key, int val) {
        int index = key % array.length;
        Node cur = array[index];
        while(cur != null) {
            if(cur.key == key) {
                cur.val = val;
                return;
            }else {
                cur = cur.next;
            }
        }
        Node newOne = new Node(key, val);
        newOne.next = array[index];
        array[index] = newOne;
        useSize++;
        if(calculateLoadFactor() > Load_FACTOR) {
            resize();
        }
    }

    private void resize() {
        Node[] newArr = new Node[array.length * 2];
        for (int i = 0; i < array.length; i++) {
            while(array[i] != null) {
                int index = array[i].key % newArr.length;
                Node cur = newArr[index];
                Node newOne = new Node(array[i].key, array[i].val);
                if(cur == null) {
                    newArr[index] = newOne;
                }else {
//  尾插               while(cur.next != null) {
//                        cur = cur.next;
//                    }
//                    cur.next = new Node(array[i].key, array[i].val);
                    newOne.next = cur;
                    newArr[index] = newOne;
                }
                array[i] = array[i].next;
            }
        }
        array = newArr;
    }

    private double calculateLoadFactor() {
        return (double) useSize / array.length;
    }
    public int get(int key) {
        int index = key % array.length;
        Node cur = array[index];
        while(cur != null) {
            if(cur.key == key) {
                return cur.val;
            }
            cur = cur.next;
        }
        return -1;
    }
}

4. 数据类型为引用类型

  • 我们刚才用的是int[ ] ，如果是String类型，自定义类型呢？
  • 那么这里就需要用到一个方法hashcode() ，这个方法可以获取到哈希值（引用类型的身份证），这样就可以进行取模运算了
    • 如果是自定义类型，我们得自己重写hashcode()方法,String系统已经重写了
    • 一定一定要重写equals()方法，否则我们认为相同的两个引用，哈希值也会不同
  • 下面是泛型版本：
public class MyHashMap <K, V> {

    //如果用到泛型的话，记住要重写一些方法，如equals 和 hashCode
    //以及在特定位置补上自己的哈希方法

    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>[] array;
    public int useSize;
    public static final double Load_FACTOR = 0.75;//"全局"常数



    public MyHashMap() {
        array = (Node<K,V>[])(new Node[10]);
    }
    
    public void put(K key, V val) {
        int index = key.hashCode() % array.length;
        Node<K, V> cur = array[index];
        while(cur != null) {
            if(cur.key.equals(key)) {
                cur.val = val;
                return;
            }else {
                cur = cur.next;
            }
        }
        Node<K, V> newOne = new Node<>(key, val);
        newOne.next = array[index];
        array[index] = newOne;
        useSize++;
        if(calculateLoadFactor() > Load_FACTOR) {
            resize();
        }
    }

    private void resize() {
        
        Node<K, V>[] newArr = (Node<K,V>[]) (new Node[array.length * 2]);
        for (int i = 0; i < array.length; i++) {
            while(array[i] != null) {
                int index = array[i].key.hashCode() % newArr.length;
                Node<K, V> cur = newArr[index];
                Node<K, V> newOne = new Node<>(array[i].key, array[i].val);
                if(cur == null) {
                    newArr[index] = newOne;
                }else {
//  尾插               while(cur.next != null) {
//                        cur = cur.next;
//                    }
//                    cur.next = new Node(array[i].key, array[i].val);
                    newOne.next = cur;
                    newArr[index] = newOne;
                }
                array[i] = array[i].next;
            }
        }
        array = newArr;
    }

    private double calculateLoadFactor() {
        return (double) useSize / array.length;
    }
    public V get(int key) {
        int index = key % array.length;
        Node<K, V> cur = array[index];
        while(cur != null) {
            if(cur.key.equals(key)) {
                return cur.val;
            }
            cur = cur.next;
        }
        return null;
    }
}

  • 在这里插入图片描述

    • 数组的构建参考的是hashMap源码
      • 在这里插入图片描述

  • 下面是随便一个自定义类：

    • class student {
    char[] name;
    int id;
    int score;
}

在这里插入图片描述

  • 【Alt + insert】后点击这个东西,一路next就好了

在这里插入图片描述

  • 我们也可以自己去决定“怎么样才算相等”，自己重写equals（）

5. 集合类的基本用途与使用

5.1 实例化Map

  • 一般用普通类实例化接口的形式，这样这个引用的功能更加具有针对性。

  • 接下来来看看Map的一些基本功能（高亮即重点）

  • 方法解释
    V get(Object key)返回key对应的value值
    V getOrDefault(Object key, V defaultValue)返回对应value，不存在则返回defaultValue
    V put(K key, V value)放置键值对（key重复则覆盖）
    V remove(Object key)根据唯一的key删除键值对
    Set keySet()key不重复，将所有key值放在Set里并返回
    Collection values()将所有values放在集合中并返回
    Set<Map.Entry<K, V>> entrySet()返回所有键值对集（entry即条目）
    boolean containsKey(Object key)是否存在key值
    boolean containsValue(Object value)是否存在value值

  • 其中还有一个特别重要的静态内部接口，Entry

  • 这里我们可以理解为，将key和value打包起来了，成为一个独立的引用，其实里面

  • 方法解释
    K getKey()获取键值对的key值
    V getValue()获取键值对的value值
    V setValue(V value)设置键值对的value值
    Set<Map.Entry<Integer, Integer>> set = hashMap.entrySet();
Map.Entry<Integer, Integer>[] entry = (Map.Entry<Integer, Integer>[]) set.toArray();//把map的 key 和 value 组装成一个整体
entry[0].getKey();
entry[0].getValue();
entry[0].setValue();

  • 无法设置key，转化为Set有什么用，等一下将Set的时候细说！

  • 接下来解答一些疑惑，就是为什么返回类型是接口/抽象类型，但是仍然可以正常使用？

    • 原因就是，重写方法的规矩除了完全相等以外，还有一个例外
      • 就是，返回类型呈现继承/实现关系，【父亲方法的返回类型】被【子类方法的返回类型】继承或者实现，也是重写！
      • 这样，返回类型就可以是普通类啦，并且哈希实现就是哈希，树实现就是树。

  • 至于Entry的本质

    • 在这里插入图片描述

    • 这是源码，Entry被Node实现后，

      • 只要被Node实例化，【对应的引用就有了对应的Node】，也就有了对应的【key，value】
      • 这是因为，方法被重写后，访问key和value并非private
        • 这样就能够在父类访问子类成员了！
        • 这样，使用Entry的get…方法，就相当于有对应的Node引用使用了get…方法，就获取到了对应的key，value值

    • 对于entrySet()方法

    • 在这里插入图片描述

    • 看不懂不重要，重要的是解决了我们的疑问

      • 就是，Entry被一个特定的Node实例化后，Node被删除，还访问得到吗？
      • 明确的告诉你，还可以，因为这里的节点被（深）拷贝了一份，Entry是被这份拷贝实例化的！
注意
  1. key唯一，value不唯一，key不可被设置，只能删掉重新放置
  2. 哈希里是可以存放null的，而树不可以（因为null不能比较，会抛异常的）
  3. Map并不是”Collection家族“的

5.2 实例化Set

  • 下面是Set的基本功能（高亮即重点）

  • 方法解释
    boolean add(E e)增加元素，重复则会失败，返回false
    void clear()清空集合
    boolean contains(Object o)查看元素是否存在
    Iterator iterator()返回迭代器
    boolean remove(Object o)删除对应元素
    int size()返回集合大小
    boolean isEmpty()集合是否为空
    Object[] toArray()转化为数组（非基本数据类型数组！）
    boolean containsAll(Collection<?> c)查询c集合的所有元素是否个个都存在
    boolean addAll(Collection<? extends E> c)添加一整个集合的所有元素，去重作用（完全不重复则返回true）（有现成的集合类的时候适用）
    5.2.1 迭代器

    • 这个“工具”的作用就是遍历集合

    • 用法如下：

      • ​ hasNext() 与 next() 这两个方法打配合
    • public static void main(String[] args) {
    Map<String, Integer> hashMap = new HashMap<>();
    hashMap.put("小卡拉", 3);
    hashMap.put("马拉圈", 4);
    hashMap.put("芜湖", 5);
    System.out.println(hashMap.get("小"));
    
    Set<Map.Entry<String, Integer>> set = hashMap.entrySet();
    
    //for-each 语法遍历
    for(Map.Entry<String, Integer> s : set) {
        System.out.print(s.getKey() + " " + s.getValue() + " ");
    }
    
    //迭代器遍历法
    Iterator<Map.Entry<String, Integer>> iter =  set.iterator();
    //Iterator<?> 用通配符也可以
    while(iter.hasNext()) {
        System.out.print(iter.next() +  " ");
    }

}
5.2.2 toArray()

  • 这个方法有两个用法

  • (T[])set.toArray();
//需要强制类型转化！由于擦除机制，数组的返回是Object[]

  • set.toArray(arr);
//这个arr必须是对应的非基本数据类型数组！或者父类数组
//set里面的元素被整合到arr里了
//返回值可以不接收，接收的话，方式跟上面一样

  • 需要重点强调的一点是，基本数据类型的数组与其包装类的数组不能直接相互转化（自然也不存在自动拆箱装箱），必须遍历一遍！！！

其他方法相对简单，不细说

注意
  1. Set是Collection家族的接口类
  2. key值唯一，Set重点在于除重
  3. key要修改，必须删除再添加
  4. 树的key不能是null，因为需要比较
  5. TreeSet/HashSet底层由Map实现，value为Object类型的一个默认对象，key就是key
    • 节省功夫嘛

在这里插入图片描述

  • Set和Map 还可用 LinkedHashSet和LinkedHashMap实例化
    • 这维护了双向链表，可以记录元素的插入次序

6. 哈希部分源码

  • 刚才已经接触了一些源码了，接下来只有一些补充了

6.1 HashMap

6.1.1 一些常量

  • 在这里插入图片描述

    • 在这里插入图片描述

      • 这个是默认的表的默认容量

    • 在这里插入图片描述

      • 这个是表的最大容量

    • 在这里插入图片描述

      • 这个是负载因子默认最大值

    • 在这里插入图片描述

      • 这个哈希桶树化临界值
        • 即桶内节点达到8，就会折叠成红黑树（原本只是链表）

    • 在这里插入图片描述

      • 这个是哈希桶退化为链表的临界值
        • 即桶内节点被删除到6，就会退化成链表（原本是红黑树）

    • 在这里插入图片描述

      • 这个是哈希桶树化前提的前提
        • 就是，表的容量很少时，可能会导致桶内的东西太多了【就是冲突次数多】
        • 那么规定一个值，当表的已有元素总数（节点总个数）达到这个值的时候，才考虑折叠链表为红黑树，其他情况直接扩容即可【其他情况是指，桶内元素达到界值后不选择树化，而是扩容哈希表】
        • 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD

    • 树化方法treeifyBin 就不带大家看了

6.1.2 哈希方法

在这里插入图片描述

  • 此方法的作用是让值放的更分散
6.1.3 调整容量

  • 这个操作是将容量调整为最接近的二进制数（较大）

    • 即2, 4, 8, 16…
    • 原理就是，让二进制序列最左边的1之后的位都变成1，
      • 【10101】= =》【11111】= =》【100000】
      • 右移按位与是让这个位【1】成倍数往后扩展
        • 就是原本可能只有一个1扩展为两个1，扩展到四个1，这样最快
          在这里插入图片描述

  • 在一个构造方法中有用到

    • 用途：搭配哈希方法降低冲突率
6.1.4 构造方法

在这里插入图片描述

  1. 提供容量和负载因子
  2. 提供容量
  3. 什么都不提供
  4. 提供一个Map，将整个Map的所有元素（拷贝成新的一个引用）
6.1.5 LinkedHashMap
  • 在HashMap中并没有实例化对象LinkedHashMap的构造方法，但是有继承它的…
  • 在这里插入图片描述
  • 了解即可

6.2 HashSet

  • 底层也是Map，key就是key，value是一个Object默认值
  • 主要带大家看看构造方法
  • 在这里插入图片描述
  1. 不带参数构造方法
  2. 提供一个集合引用，将所有元素导入Set里
  3. 提供容量和负载因子
  4. 提供容量
  5. 提供容量，负载因子以及布尔类型

    • 这个类型并没有什么用，只是区分其他构造方法而已

    • 在这里插入图片描述

    • 就是构造LinkedHashMap( )

    • 本质上LinkedHashSet就是用到的就是这个方法

    • 在这里插入图片描述

文章到此结束！谢谢观看
可以叫我 小马，我可能写的不好或者有错误，但是一起加油鸭🦆！

这是我的代码仓库！（在马拉圈的23.2里）代码仓库

Map&Set · 代码位置

邮箱：2040484356@qq.com

s:103
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java集合-HashSet的使用
06-14
HashSet 是 Java 中的一个集合类，它实现了 Set 接口并提供了基于哈希表的无序、不重复元素的集合。具体来说，它是通过哈希表（实际上是一个 HashMap 实例）来存储元素的。 以下是 HashSet 的一些主要特点： 无序...
Java数据结构和算法（十三）——哈希表
IT可乐
01-26 250
　　Hash表也称散列表，也有直接译作哈希表，Hash表是一种根据关键字值（key - value）而直接进行访问的数据结构。它基于数组，通过把关键字映射到数组的某个下标来加快查找速度，但是又和数组、链表、树等数据结构不同，在这些数据结构中查找某个关键字，通常要遍历整个数据结构，也就是O(N)的时间级，但是对于哈希表来说，只是O(1)的时间级。 　　注意，这里有个重要的问题就是如何把关...
哈希表类Hashtable
szanjie的专栏
05-10 930
哈希表类Hashtable 来源:http://www.javaresearch.org/article/showarticle.jsp?column=545&thread=17460　　哈希表是一种重要的存储方式，也是一种常见的检索方法。其基本思想是将关系码的值作为自变量，通过一定的函数关系计算出对应的函数值，把这个数值解释为结点的存储地址，将结点存入计算得到存储地址所对应的存储单元。检索时
HashSet、HashMap，散列表数据结构（哈希表）
Thinking_IN_Java
06-06 4512
HashSet、HashMap，散列表数据结构（哈希表） 前几天介绍了ArrayList的底层实现以及对性能的简单分析。今天再来看看HashSet，HashMap。 HashSet: 很多开发者，初学者都知道HashSet无序，不可重复，线程非同步。底层是哈希表结构。 但它是怎么做到的？什么是散列表数据结构（哈希表）？有什么特性？都清楚吗？不清楚继续往下看。 它是
JAVA数据结构和算法：第四章（HashMap和HashSet底层原理及实现）
春水上行的博客
08-27 8347
HashMap内部原理及实现什么是哈希表？哈希表（hash table）也叫散列表，是一种非常重要的数据结构，我们先来看一下其他数据结构的特点。 数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n) 链表：对于
Java中常见数据结构Set之HashSet
weixin_33935777的博客
09-10 168
今天来说说Java集合中的Set系列之HashSet。   Set我们众所周知的就是虑重功能， 我们平时在项目开发中也常用到这个特性的。那么Set为何能够虑重呢？ 接下来我们就看下源码吧。   Set的底层实现是HashMap（这个后面讲Map时也会讲它的源码）， 当我们在HashSet中添加一个新元素时， 其实这个值是存储在底层Map的key中，而众所周知，HashMap的key值是不能...
Java集合框架源码剖析：HashSet 和 HashMap
12-22
　之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 　HashMap实现了Map...
HashMap底层实现原理HashMap与HashTable区别HashMap与HashSet区别.docx
01-03
HashMap、HashTable和HashSet是Java中常用的数据结构，它们的底层实现原理以及区别如下：HashMap底层实现原理： HashMap基于哈希表（HashTable）实现，它通过散列算法将键值对映射到数组中。在HashMap中，每个键值对...
Java超详细！Java实现数据结构PPT课件
最新发布
02-24
哈希表（HashTable） 树形数据结构 二叉树（BinaryTree）、二叉搜索树（BinarySearchTree、BST） 平衡二叉搜索树（BalancedBinarySearchTree、BBST） AVL树（AVLTree）、红黑树（RebBlackTree） B树（B-Tree） 集合...
DataStructures:Java Java中的通用数据结构
05-16
Java中的数据结构 一些通用数据结构的实现 数据结构 链表 数组列表 堆 队列 哈希图 哈希集 二进制搜索树 堆 特里 AVL树 测验 使用JUnit5的单元测试涵盖了整个项目。 当前的行覆盖率是92％
JAVA哈希表
蒙面侠的博客
03-08 1717
哈希表的定义 哈希表（Hash table，也叫散列表）是一种查找算法，与链表、树等算法不同的是，哈希表算法在查找时不需要进行一系列和关键字的比较操作。 哈希表算法希望能尽量做到不经过任何比较，通过一次存取就能得到所查找的数据元素，因而必 须要在数据元素的存储位置和它的关键字（可用key表示）之间建立一个确定的对应关系，使每个关键字和散列表中一个唯一的存储位置相对应。因此在查找时，只要根据这个对应关系找到给定 关键字在散列表中的位置即可。这种对应关系被称为哈希函数(可用H(key)表示) 哈希函数的构造方法
Java哈希表
qq_44118534的博客
01-02 228
1. 概念 在顺序结构和平衡树中，元素与其存储位置之间没有对应的关系，因此在查找一个元素时必须经过元素之间的多次比较，顺序查找时间复杂度为O(n)，平衡树中的时间复杂度为O(log2 n)，搜索效率与比较的次数有关。 理想的搜索方法：可以不经过比较就可以得到要搜索的元素。如果构造一种存储结构，通过某种函数（hashfunc）来使元素与存储位置之间能够建立一一映射的关系，那么在查找时通过该函数就可以很快的找到该元素。 元素插入 在元素插入时通过此函数计算出该元素的存储位置将其插入。 元素搜索 因为元素是按.
java hashset hashmap
09-25
HashSet 和 HashMap 是 Java 中的两个常用集合类。 HashSet 是基于哈希表实现的，它继承自 AbstractSet 并且实现了 Set 接口。HashSet 是一个无序的集合，它不允许重复元素。当我们向 HashSet 中添加元素时，它会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

s:103

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值