Java 【数据结构】 哈希（Hash超详解）HashSetHashMap【神装】

news2024/9/22 9:46:42

 登神长阶

第十神装 HashSet

第十一神装  HashMap

目录

👔一.哈希

🧥1.概念

🩳2.Object类的hashCode()方法:

👚3.String类的哈希码:

👠4.注意事项:

🎷二.哈希桶

🪗1.哈希桶原理

🎸2.哈希桶的实现细节

🪘3.总结

📲三.解决哈希冲突的常用方法*

💰四.HashSet

🪙1.定义

💵2.操作

💶3.特性

💷4.内部实现

💳5.应用场景

✏️五.HashMap

✒️1.定义

🖋️2.操作

🖊️3.特性

🖍️4.内部实现

🖌️5.应用场景

📝六.对比

 💼七.总结与反思

👔一.哈希

🧥1.概念

        在Java中，哈希（Hash）是一个广泛应用于数据结构和算法中的概念，主要用于快速查找、存储和比较数据。哈希的核心在于哈希函数（Hash Function），它将输入（通常称为键，key）映射到一个固定范围的输出值，这个输出值称为哈希值（Hash Value）或哈希码（HashCode）。哈希的目的在于将原本复杂、不规则的数据转化为简洁的、固定长度的值，使得数据的存储和检索更加高效。

🩳2.Object类的hashCode()方法:

Java中的每个对象都继承自Object类，而Object类有一个hashCode()方法，这个方法被设计用来返回对象的哈希码。默认的hashCode()实现通常基于对象的内存地址，但子类通常会重写此方法，以便根据对象的实际内容生成更有意义的哈希值，这对于使用对象作为键的哈希表操作尤为重要。

  1. 作用：

    • hashCode()方法返回对象的哈希码值（哈希码），是一个int类型的整数。
    • 哈希码是根据对象的内存地址或者根据对象的内容计算得到的一个唯一标识符。
    • 在Java中，hashCode()方法通常与equals()方法一起使用，用于判断两个对象是否相等。

  2. 默认实现：

    • 在Object类中，hashCode()方法的默认实现是根据对象的内存地址计算得到的哈希码。
    • 换句话说，如果两个对象在内存中的地址不同，那么它们的哈希码也会不同。

  3. 重写规则：

    • 在自定义类中，通常需要重写hashCode()方法，以便根据对象的内容来生成哈希码，而不是依赖于默认的内存地址。
    • 如果重写了equals()方法，就应该同时重写hashCode()方法，保证相等的对象拥有相等的哈希码。
    • 重写hashCode()方法时，应该遵循以下规则：
      1. 相等的对象必须具有相等的哈希码。
      2. 不相等的对象尽量产生不同的哈希码，以减少哈希冲突的发生。

  4. 使用场景：

    • 在集合类中，如HashMap、HashSet等，hashCode()方法被用于确定对象在集合中的存储位置，加快数据的查找速度。
    • 当我们需要比较自定义类的对象是否相等时，通常会重写equals()和hashCode()方法。

        总之，Object类的hashCode()方法是用于获取对象的哈希码的方法，可以通过重写该方法来根据对象的内容生成哈希码，以便在集合中进行快速查找和比较。

👚3.String类的哈希码:

String类是一个典型重写了hashCode()方法的类，它根据字符串的内容计算哈希值，这意味着内容相同的字符串将拥有相同的哈希值，这有助于在哈希表中快速定位和比较字符串。

👠4.注意事项:

  • 哈希函数应该是高效的，即计算速度快。
  • 哈希函数应该尽量均匀分布，以减少哈希冲突。
  • 哈希值虽然可以用于快速比较，但不保证绝对唯一，因此在判断对象相等时，除了比较哈希值外，还需要比较对象的实际内容（通过equals()方法）。
  • 在实现自定义类的hashCode()时，应当遵守与equals()方法的一致性原则，即如果两个对象通过equals()判断为相等，它们的哈希码也必须相等。反之，哈希码相等的对象不一定通过equals()判断相等。

🎷二.哈希桶

        哈希桶（Hash Bucket）是哈希表（Hash Table）中用于解决哈希冲突的一种常用方法，它是哈希表数据结构的一个重要组成部分。哈希桶是哈希表中存储元素的地方，通常是一个数组。每个桶都有一个索引，通过哈希函数计算得到的哈希值会决定元素被放置在哪个桶中。

🪗1.哈希桶原理

        哈希桶解决哈希冲突的方法是，将哈希表的每个槽（或索引）扩展为一个“桶”（Bucket），这个桶本质上是一个数据结构（通常是链表、数组或其他容器），可以存储多个具有相同哈希值的元素。具体来说，当一个键通过哈希函数计算得到的索引已经有其他元素时，新的元素会被添加到这个索引对应的桶中，而不是覆盖原有的元素。

🎸2.哈希桶的实现细节

  1. 哈希函数：用于将键转换成索引。好的哈希函数能够尽量均匀地分布元素，减少冲突。

  2. 桶的实现：常用的桶实现是链表，因为链表插入和删除操作的时间复杂度较低。但在Java 8以后的HashMap中，当桶中的元素数量达到一定阈值时，会将链表转换为红黑树，以进一步优化查询性能。

  3. 负载因子：表示哈希表中已填入元素的数量与哈希表长度的比例，用于衡量哈希表的填充程度。当负载因子超过某个预设值时，哈希表会进行扩容，重新调整大小，以减少冲突，保持高效性能。

  4. 扩容：扩容通常涉及创建一个新的、更大容量的哈希表，并将原哈希表中的所有元素重新哈希到新表中。这个过程可以确保桶的平均长度减少，从而减少冲突。

  5. 冲突处理：当多个键映射到同一索引时，桶中的链表（或红黑树）结构用于存储这些冲突的键值对，并通过遍历链表（或树）来查找具体的元素。

🎹源代码模拟实现

// key-value 模型
public class HashBucket {
    private static class Node {
        private int key;
        private int value;
        Node next;


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

    private Node[] array;
    private int size;   // 当前的数据个数
    private static final double LOAD_FACTOR = 0.75;
    private static final int DEFAULT_SIZE = 8;//默认桶的大小

    public int put(int key, int value) {
        int index = key % array.length;
        Node cur = array[index];
        //遍历当前列表，看是否存在当前值
        while (cur != null) {
            if (cur.key == key) {
                cur.value = value;
            }
            cur = cur.next;
        }
        //若无当前值，则进行头插法
        Node node = new Node(key, value);
        node.next = array[index];
        array[index] = node;
        size++;
        //判断是否超载
        if (loadFactor()>=LOAD_FACTOR){
            //扩容
            resize();
        }
        return 0;
    }


    private void resize() {
        Node[] newArr=new Node[array.length*2];
        for (int i = 0; i < array.length; i++) {
            Node cur=array[i];
            while(cur!=null){
                //遍历链表，将数据储存到新数组
               int newIndex=cur.key% newArr.length;
               Node curN=cur.next;
               cur.next=newArr[newIndex];
               newArr[newIndex]=cur;
               cur=curN;
            }
        }
        array=newArr;
    }


    private double loadFactor() {
        return size * 1.0 / array.length;
    }


    public HashBucket() {
        array=new Node[10];
    }


    public int get(int key) {
         int index=key%array.length;
         Node cur=array[index];
         while(cur!=null){
             if (cur.key==key){
                 return cur.value;
             }
             cur=cur.next;
         }
         return -1;
    }
}

🪘3.总结

        哈希桶机制通过将冲突的元素组织在一起，而非直接覆盖，保证了哈希表的灵活性和高效性。它允许哈希表在面对大量数据时仍能保持较好的性能，尤其是在冲突较多的情况下。通过调整哈希函数、负载因子和适时的扩容，可以进一步优化哈希表的效率。在Java中，HashMap和HashSet就是使用哈希桶来实现的，它们是Java集合框架中非常重要的组件。

📲三.解决哈希冲突的常用方法*

        解决哈希冲突是哈希表设计中的关键环节，目的是确保即使两个或多个键通过哈希函数计算出相同的索引，也能高效地存储和检索这些键值对。以下是几种常用的解决哈希冲突的方法：

1. 开放定址法（Open Addressing）

  • 线性探测法（Linear Probing）：当发生冲突时，从冲突位置开始，沿着数组线性地检查下一个位置，直到找到一个空位。这种方法简单，但容易造成“聚集”现象，影响查找效率。
  • 二次探测法（Quadratic Probing）：在冲突发生后，按照某种探测序列（通常是二次的，如i^2 + c）寻找下一个空位，这可以减少聚集现象。
  • 双重散列法（Double Hashing）：使用第二个哈希函数来计算步长，当发生冲突时，按步长跳跃寻找下一个可用位置，以减少探测的顺序性。

2. 再哈希法（Rehashing）

当第一个哈希函数导致冲突时，使用第二个、第三个不同的多个哈希函数继续尝试寻找空闲位置。这种方法减少了冲突的机会，但增加了计算开销。

再哈希法通过使用一系列哈希函数不断尝试新的位置，而双重散列法则通过一个固定的步长规则在哈希表中进行探测。

3. 链地址法（Separate Chaining）

每个哈希表的索引位置对应一个链表或其它动态数据结构（如红黑树，Java 8中HashMap的实现）。当发生冲突时，将新的元素添加到该索引位置的链表中。这种方法简单且灵活，但链表过长时会降低查找效率。

4. 建立公共溢出区（Overflow Area）

这种方法将哈希表分为两个部分：基本表和溢出表。当基本表中的位置已满时，冲突的元素被放置在溢出表中。这种方式实现简单，但效率不如链地址法。

5. 开散列法（Open Hashing）*

这是一种特殊的链地址法，哈希表本身是一个指针数组，每个元素指向一个链表的头节点。这种方法强调了链表的独立性，便于管理和扩展。

负载因子调整

        无论采取哪种冲突解决策略，维护一个合理的负载因子（已用单元数与总单元数的比例）至关重要。当负载因子超过某个阈值时，通常会触发哈希表的扩容操作，通过增大哈希表的大小并重新分配所有元素来减少冲突，保持高效的查找性能。

        每种方法都有其优势和劣势，实际应用时需根据具体需求和数据特点选择最适合的冲突解决策略。例如，对于内存充足的场景，链地址法因其实现简单且效果稳定而常用；而在内存受限或查找性能要求极高的场景下，开放定址法或再哈希法可能更为合适。

💰四.HashSet

此部分建议，对照上一篇来学习        Java 【数据结构】 TreeSet&TreeMap（二叉搜索树详解）【神装】

🪙1.定义

        Java中的HashSet是一个实现了Set接口的集合类，它提供了一种存储不可重复元素的高效数据结构。HashSet的实现基于HashMap，这意味着它内部使用了哈希表来管理元素，这使得HashSet能够提供快速的插入、删除和查找操作。以下是关于HashSet的一些关键特性和内部工作原理的详细说明：

💵2.操作

方法

解释

boolean add(E e)

添加元素，但重复元素不会被添加成功

void clear()

清空集合

boolean contains(Object o)

判断 o 是否在集合中

Iterator<E> 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中，可以达到去重的效果

源代码 

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        // 创建一个HashSet实例
        HashSet<String> myHashSet = new HashSet<>();

        // 添加元素
        myHashSet.add("Apple");
        myHashSet.add("Banana");
        myHashSet.add("Cherry");
        System.out.println("HashSet after adding elements: " + myHashSet);

        // 检查元素是否存在
        boolean isPresent = myHashSet.contains("Banana");
        System.out.println("Is 'Banana' in the HashSet? " + isPresent);

        // 尝试添加重复元素
        myHashSet.add("Apple");
        System.out.println("HashSet after trying to add duplicate 'Apple': " + myHashSet);
        
        // 删除元素
        boolean isRemoved = myHashSet.remove("Banana");
        System.out.println("Is 'Banana' removed? " + isRemoved);
        System.out.println("HashSet after removing 'Banana': " + myHashSet);

        // 遍历HashSet
        System.out.println("Iterating over HashSet:");
        for (String fruit : myHashSet) {
            System.out.println(fruit);
        }
        
        // 清空HashSet
        myHashSet.clear();
        System.out.println("HashSet after clearing: " + myHashSet);
    }
}

💶3.特性

  1. 无序性：HashSet不保证元素的插入顺序，每次遍历HashSet时，元素的顺序可能不同。这是因为HashSet在内部使用哈希表，元素的存储位置由其哈希值决定。

  2. 不允许重复：HashSet中不能包含重复的元素。这是通过比较元素的哈希值以及equals()方法来实现的。如果两个元素的哈希值相同，并且通过equals()方法比较也认为是相等的，则视为重复元素，后者将不会被加入集合中。

  3. 允许null值：HashSet允许存储一个null元素，因为HashMap允许一个键为null。

  4. 非线程安全：HashSet不是线程安全的。如果多个线程同时访问一个HashSet，且至少有一个线程修改了HashSet，则必须通过外部同步来保证线程安全。

💷4.内部实现

  • 基于HashMap：HashSet实际上是一个包装器，它将每个元素作为HashMap的键，并且所有元素共享一个静态的、唯一的值对象作为映射的值。这意味着HashSet中元素的添加、删除等操作实际上是在操作底层的HashMap。

  • 哈希值与索引：当向HashSet添加元素时，首先调用该元素的hashCode()方法计算哈希值，然后使用哈希值来确定元素在底层数组中的索引位置。如果该位置已有元素（哈希冲突），则使用链地址法（在JDK 7及以前是单向链表，在JDK 8中引入了红黑树，当链表长度超过8时会转换为红黑树）来存储多个具有相同索引的元素。

  • 扩容机制：当HashSet中的元素数量超过其当前容量乘以负载因子时，HashSet会自动进行扩容，以减少哈希冲突并保持高效的查找性能。扩容包括创建一个新的更大的数组，并将原数组中的所有元素重新哈希到新数组中。

  • 重写equals()与hashCode()：为了确保HashSet能正确识别重复元素，存储在HashSet中的自定义对象必须正确重写equals()和hashCode()方法，保证相等的对象具有相同的哈希值，并且通过equals()方法判断也为相等。

💳5.应用场景

Java中的HashSet是一个高效无序且不允许重复元素的集合类，基于HashMap实现。

  • 它的核心应用场景包括数据去重、集合运算、缓存实现、快速查找成员、统计唯一元素、辅助高级数据结构及游戏开发中的对象管理等。
  • HashSet利用哈希机制提供快速的插入、删除和查找功能，特别适合需要高效率集合操作的场景。

        HashSet是Java集合框架中一个非常实用的类，特别适用于需要快速插入、删除和查找，且不需要维护元素插入顺序的场景。理解其基于HashMap的实现以及如何利用哈希机制来管理元素，对于高效使用HashSet至关重要。

✏️五.HashMap

 此部分建议，对照上一篇来学习        Java 【数据结构】 TreeSet&TreeMap（二叉搜索树详解）【神装】

✒️1.定义

Java中的HashMap是一个实现Map接口的类，它提供了一个存储键值对（key-value pairs）的数据结构。HashMap允许使用唯一的键来映射到特定的值，并且能够高效地进行插入、删除和查找操作。键值对之间没有特定的顺序，HashMap也不是线程安全的。

🖋️2.操作

方法

解释

V get(Object key)

返回 key 对应的 value

V getOrDefault(Object key, V defaultValue)

返回 key 对应的 value，key 不存在，返回默认值

V put(K key, V value)

设置 key 对应的 value

V remove(Object key)

删除 key 对应的映射关系

Set<K> keySet()

返回所有 key 的不重复集合

Collection<V> values()

返回所有 value 的可重复集合

Set<Map.Entry<K, V>> entrySet()

返回所有的 key-value 映射关系

boolean containsKey(Object key)

判断是否包含 key

boolean containsValue(Object value)

判断是否包含 value

源代码

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例
        HashMap<String, Integer> myHashMap = new HashMap<>();

        // 添加键值对
        myHashMap.put("Apple", 1);
        myHashMap.put("Banana", 2);
        myHashMap.put("Cherry", 3);
        System.out.println("HashMap after adding elements: " + myHashMap);

        // 更新键对应的值
        myHashMap.put("Apple", 4);
        System.out.println("HashMap after updating 'Apple': " + myHashMap);

        // 检查键是否存在
        boolean isPresent = myHashMap.containsKey("Banana");
        System.out.println("Is 'Banana' a key in the HashMap? " + isPresent);

        // 删除键值对
        myHashMap.remove("Banana");
        System.out.println("HashMap after removing 'Banana': " + myHashMap);

        // 遍历HashMap
        System.out.println("Iterating over HashMap:");
        for (Map.Entry<String, Integer> entry : myHashMap.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // 获取特定键的值
        Integer appleValue = myHashMap.get("Apple");
        System.out.println("Value of 'Apple': " + appleValue);

        // 检查一个键是否存在且获取其值
        Integer orangeValue = myHashMap.getOrDefault("Orange", -1); // 如果没有找到键'Orange'，则返回-1
        System.out.println("Value of 'Orange' or default: " + orangeValue);
    }
}

🖊️3.特性

  1. 键值关联：HashMap存储的是键值对，其中键是唯一的，而值可以重复。
  2. 无序性：HashMap中的元素没有特定的顺序，迭代时的顺序并不反映插入时的顺序。
  3. 允许null值和null键：HashMap是少数几个可以接受null键和null值的Java集合之一，但每个HashMap只能有一个null键。
  4. 线程不安全：HashMap不是线程安全的，多线程环境下若不采取额外的同步措施，可能导致数据不一致性。
  5. 可调整大小：随着元素的增加，HashMap会自动扩容来维持其性能，通过重新哈希所有元素到更大的数组中实现。
  6. 性能：平均情况下，HashMap提供O(1)的时间复杂度进行插入、删除和查找操作。

🖍️4.内部实现

  1. 哈希表：HashMap的底层实现是一个哈希表，它由一个动态调整大小的数组（称为桶或bin）组成，数组的每个位置可以是一个链表或红黑树（JDK 8开始）。

  2. 哈希函数：HashMap使用哈希函数将键转换成数组的索引。哈希冲突通过链地址法解决，即在同一索引位置的多个元素通过链表或红黑树链接起来。

  3. 负载因子：HashMap有一个负载因子，默认为0.75，它决定了HashMap何时进行扩容。当HashMap中的元素数量超过当前容量乘以负载因子时，HashMap会自动扩容，一般扩容为原来的两倍。

  4. 扩容机制：扩容时，HashMap会创建一个新的更大容量的数组，并将原数组中的所有元素重新哈希到新数组中，这个过程涉及到重新计算哈希值和重新分配。

🖌️5.应用场景

  1. 缓存：HashMap非常适合做轻量级的缓存，快速存取热点数据。
  2. 数据映射：在需要快速根据键查找相关联值的场景，如配置参数管理。
  3. 计数：可以用HashMap统计元素出现的频率，键是元素，值是出现次数。
  4. 去重：虽然HashSet更直接，但在需要存储额外信息或自定义比较逻辑时，HashMap可以用来去重。
  5. 图的邻接表表示：在图算法中，HashMap可以用来表示顶点的邻接关系，键是顶点，值是一个列表或集合，包含与该顶点相邻的所有顶点。

综上，HashMap凭借其高效的查找和灵活的键值对存储机制，在众多Java应用中扮演着核心角色。

📝六.对比

Set

Set底层结构

TreeSet
HashSet

底层结构

红黑树
哈希桶

插入/删除/查找时间

复杂度

O(log N)
O(1)

是否有序

关于Key有序
不一定有序

线程安全

不安全

不安全

插入/删除/查找区别

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

比较与覆写

key必须能够比较，否则会抛出

ClassCastException异常
自定义类型需要覆写 equals 和
hashCode 方法

应用场景

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

Map

Map底层结构

TreeMap
HashMap

底层结构

红黑树
哈希桶

插入/删除/查找时间

复杂度

O(log N)O(1)

是否有序

关于Key有序
无序

线程安全

不安全
不安全

插入/删除/查找区别

需要进行元素比较
通过哈希函数计算哈希地址

比较与覆写

key必须能够比较，否则会抛出

ClassCastException异常
自定义类型需要覆写 equals 和
hashCode 方法

应用场景

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

 💼七.总结与反思

盛年不重来，一日难再晨，及时当勉励，岁月不待人。——陶渊明

HashSet学习总结

HashSet是Java集合框架中实现Set接口的一个重要类，它提供了一种无序且不重复元素的集合。HashSet的核心特点是：

  1. 不重复性：HashSet不允许存储重复的元素，这是通过调用元素的hashCode()和equals()方法来确保的。这两个方法共同决定元素的唯一性。
  2. 无序性：HashSet不保证元素的插入顺序，遍历HashSet时得到的顺序可能与插入顺序不同。
  3. 基于HashMap实现：HashSet实际上是对HashMap的一种包装，它将元素作为HashMap的键，而值统一设为一个固定对象（如PRESENT常量），从而达到只关心键的目的。
  4. 性能优势：得益于HashMap的哈希表实现，HashSet提供了高效的添加、删除和查找操作，平均时间复杂度接近O(1)。
  5. 注意事项：使用自定义对象作为HashSet的元素时，必须重写hashCode()和equals()方法，确保逻辑上相同（根据业务定义）的对象具有相同的哈希值和相等性判断。

HashMap学习总结

HashMap是Java中最常用的键值对集合，它实现了Map接口，提供了一种快速存取键值对的方式。HashMap的主要特征有：

  1. 键值对存储：每个元素由一个键和一个值组成，键是唯一的，值可以重复。
  2. 哈希表结构：内部使用哈希表实现，通过哈希函数将键映射到数组的特定索引，解决冲突的方法是链地址法（JDK 7及以前是链表，JDK 8引入了链表/红黑树的结构转换）。
  3. 线性探测法和扩容：当哈希碰撞导致冲突时，通过开放寻址法（如线性探测）或链表/红黑树解决。当HashMap的填充程度达到一定阈值（由负载因子控制，默认0.75），会触发扩容，以保持高效性能。
  4. 线程不安全：HashMap在多线程环境下不是线程安全的，若在并发环境中使用，推荐使用ConcurrentHashMap。
  5. null值处理：HashMap允许一个null键和多个null值，这是与某些其他集合类不同的地方。

反思

  1. 理解哈希机制的重要性：深入理解哈希函数、冲突解决策略对于高效使用HashSet和HashMap至关重要。实际开发中，合理的重写hashCode()和equals()方法能够显著提升集合操作的性能。
  2. 并发使用的风险：在多线程环境下，直接使用HashMap可能导致数据不一致。意识到这一点后，未来在设计系统时，应当优先考虑线程安全的集合类，如ConcurrentHashMap。
  3. 性能与内存权衡：虽然HashMap提供了快速的访问速度，但其内存占用相对较高，尤其是在高负载因子下。在内存敏感的应用中，应权衡性能与内存消耗，选择合适的集合类型或调整集合参数。
  4. API的深入理解：HashMap和HashSet提供了丰富的API，如computeIfAbsent()、putIfAbsent()等，这些方法在特定场景下能够简化代码，提高效率。掌握并合理利用这些高级API能够提升代码质量。

总之，深入学习HashSet和HashMap不仅要求理解其底层数据结构和实现原理，还需关注其在具体应用环境下的适用性和限制，通过实践不断加深理解，并灵活运用到项目开发中。

🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

以上，就是本期的全部内容啦，若有错误疏忽希望各位大佬及时指出💐

  制作不易，希望能对各位提供微小的帮助，可否留下你免费的赞呢🌸

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1666178.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

AI地名故事：沧联村

AI地名故事：沧联村

沧联村&#xff0c;位于黄埔区云埔街&#xff0c;与开发区东区、增城区接壤&#xff0c;辖区面积约6.58平方公里。这个村庄的历史悠久&#xff0c;充满了丰富的故事。 在很久以前&#xff0c;沧联村并未有现今的名称。然而&#xff0c;随着时间的流转&#xff0c;村庄逐渐形成…
阅读更多...
美股市场恒生指数冲刺19000点关口 地产股大涨

美股市场恒生指数冲刺19000点关口 地产股大涨

查查配5月10日电(中新财经记者 谢艺观)5月10日,港股现强势行情,恒生指数盘中一度冲至18993.28点,距离19000点关口仅一步之遥。 美港通证券以其专业的服务和较低的管理费用在市场中受到不少关注。该平台提供了实盘交易、止盈止损、仓位控制等功能,旨在为投资者提供更为全面的投…
阅读更多...
深度学习设计模式之单例模式

深度学习设计模式之单例模式

一、单例模式简介 一个类只能有一个实例&#xff0c;提供该实例的全局访问点&#xff1b; 二、单例模式实现步骤 使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。 私有构造函数保证了不能通过构造函数来创建对象实例&#xff0c;只能通过公有静态函数返…
阅读更多...
验证码生成--kaptcha

验证码生成--kaptcha

验证码生成与点击重新获取验证码 如图所示&#xff0c;本文档仅展示了验证码的生成和刷新显示。 1. 概述 系统通过生成随机验证码图像和文本。 2. 代码分析 2.1. Maven依赖 <dependency><groupId>com.github.penggle</groupId><artifactId>kaptch…
阅读更多...
VirtualBox7安装ubantu server 22.04通过NAT+Only-Host双网卡实现宿主机与虚拟机互通

VirtualBox7安装ubantu server 22.04通过NAT+Only-Host双网卡实现宿主机与虚拟机互通

目录 背景环境安装虚拟机配置网卡修改ssh端口遇到的坑参考文章 背景 时间长没用docker了&#xff0c;有些命令都快忘了&#xff0c;心血来潮想着搞个docker玩一玩&#xff0c;所以需要先搞一个虚拟机&#xff0c;因为之前CentOS用的比较多&#xff0c;所以这次想试一试ubantu。…
阅读更多...
Java入门——继承和多态（上）

Java入门——继承和多态（上）

包 包是组织类的一种方式. 使用包的主要目的是保证类的唯一性. 例如, 你在代码中写了一个 Test 类. 然后你的舍友也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致 代码不能编译通过. 导入包中的类 Java 中已经提供了很多现成的类供我们使用. 例如 public cla…
阅读更多...
【C -＞ Cpp】由C迈向Cpp （5）

【C -＞ Cpp】由C迈向Cpp （5）

标题&#xff1a;【C -> Cpp】由C迈向Cpp&#xff08;5&#xff09; 水墨不写bug &#xff08;图片来源于网络&#xff09; 不抵制失败&#xff0c;携手失败&#xff0c;迈向成功 正文开始&#xff1a; &#xff08;一&#xff09;深入理解构造函数 在之前的讲解中&#x…
阅读更多...
linux系统（ubuntu）调用科大讯飞SDK实现语音识别

linux系统（ubuntu）调用科大讯飞SDK实现语音识别

1. 科大讯飞官网 登录注册实名制 2. 点击控制台&#xff0c;创建应用 点击左侧的语音听写&#xff0c;右边下滑选择Linux&#xff0c;点击下载 选择Linux平台&#xff0c;普通版本&#xff0c;语音听写&#xff0c;SDK下载 此时将得到一个压缩包&#xff0c;选择的功能不…
阅读更多...
LVS的三种工作模式---(DR/TUN/NAT)

LVS的三种工作模式---(DR/TUN/NAT)

目录 一、NAT模式&#xff08;LVS-NAT&#xff09; 二、IP隧道模式&#xff08;LVS-TUN&#xff09; 三、DR模型--直接路由模式&#xff08;LVS-DR&#xff09; LVS/DR模式ARP抑制 原因&#xff1a; LVS的DR工作模式及配置&#xff1a; LVS的NAT工作模式及配置&#xff1…
阅读更多...
邂逅Linux--常见指令，万物为文件(一)

邂逅Linux--常见指令，万物为文件(一)

引子&#xff1a;在之前&#xff0c;我们经常听到Linux&#xff0c;那什么是Linux呢&#xff1f;Linux是一种免费使用和自由传播的类UNIX操作系统&#xff0c;其内核由林纳斯本纳第克特托瓦兹&#xff08;Linus Benedict Torvalds&#xff09;于1991年10月5日首次发布&#xff…
阅读更多...
命令行工具部署达梦数据库 DMDPC（BP 多副本架构）

命令行工具部署达梦数据库 DMDPC（BP 多副本架构）

解达梦数据库DPC集群的主要使用场景&#xff1a; DMDPC 关注和解决的是大数据、计算与存储分离、高可用、支持全部的 SQL 标准、拥有完整的事务处理能力和集群规模能够动态伸缩的业务场景&#xff1a; 大量的复杂查询操作要求优化器能够生成优良的执行计划&#xff0c;并且执…
阅读更多...
0基础理解ECC并做题-攻防世界easy-ECC理解

0基础理解ECC并做题-攻防世界easy-ECC理解

基点p就是最初选定的那个点 1和2都是整数集合&#xff0c;但是1/20.5就不属于整数集合 一直加&#xff0c;一直乘&#xff0c;还能保证有限个数字&#xff1f;这是因为采用了取模的运算&#xff0c;让元素始终都在有限的范围内。 如何计算分数求模&#xff1f; 设n1/2mod23,那么…
阅读更多...
使用注解的方式进行配置RabbitMQ

使用注解的方式进行配置RabbitMQ

引入依赖&#xff1a; <dependency><groupId>org.springframework.amqp</groupId><artifactId>spring-rabbit-test</artifactId><scope>test</scope></dependency> 配置application.yml server:port: 8082 spring:rabbitmq…
阅读更多...
Coze扣子开发指南：AI零代码编程创建插件

Coze扣子开发指南：AI零代码编程创建插件

在Coze扣子中创建插件&#xff0c;有两种方式&#xff0c;一是用API&#xff0c;具体方式参照上一篇文章《Coze扣子开发指南&#xff1a;用免费API自己创建插件》&#xff0c;还有一种方式就是编程&#xff0c;不过有了AI的帮助&#xff0c;即使不会编程的人&#xff0c;也可以…
阅读更多...
如何清除DNS缓存，刷新DNS

如何清除DNS缓存，刷新DNS

大家在使用域名访问服务器的时候&#xff0c;经常会遇到一个问题&#xff0c;同一个局域网里的两台电脑&#xff0c;一台可以访问而另一台不行。这是为什么呢&#xff1f;这里我要和大家说下DNS缓存的问题&#xff0c;顾名思义&#xff0c;每台电脑都有DNS缓存&#xff0c;在域…
阅读更多...
MyBatis-plus（一）：快速入门

MyBatis-plus（一）：快速入门

目录 一、MyBatis-plus 快速入门 1、原理 2、实体类命名规则 3、常见注解 4、主键 id 策略 5、使用 TableField 的常见场景 6、常用配置 二、核心功能 1、条件构造器 2、自定义 SQL 3、IService 接口 一、MyBatis-plus 快速入门 1、原理 MyBatisPlus 通过扫描实体…
阅读更多...
Leetcode 剑指 Offer II 077.排序链表

Leetcode 剑指 Offer II 077.排序链表

题目难度: 中等 原题链接 今天继续更新 Leetcode 的剑指 Offer&#xff08;专项突击版&#xff09;系列, 大家在公众号 算法精选 里回复 剑指offer2 就能看到该系列当前连载的所有文章了, 记得关注哦~ 题目描述 给定链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排…
阅读更多...
STM32入门_江协科技_5~6_OB记录的自学笔记_GPIO输出_LED流水灯_蜂鸣器

STM32入门_江协科技_5~6_OB记录的自学笔记_GPIO输出_LED流水灯_蜂鸣器

5. GPIO 输出 5.1. GPIO简介 GPIO&#xff08;General Purpose Input Output&#xff09;通用输入输出口可配置为8种输入输出模式引脚电平&#xff1a;0V~3.3V&#xff0c;部分引脚可容忍5V&#xff08;端口输入5V的电压&#xff0c;之前引脚定义表格中带FT标识的&#xff09…
阅读更多...
暗区突围哪里获得测试资格 暗区突围测试资格获取方法

暗区突围哪里获得测试资格 暗区突围测试资格获取方法

在游戏业界的浩瀚星空中&#xff0c;《暗区突围》如同一颗璀璨新星&#xff0c;以其独树一帜的游戏模式和前所未有的沉浸式体验&#xff0c;迅速吸引了全球玩家的目光。它不仅仅是一款游戏&#xff0c;更像是一次对勇气、智慧与团队合作的深度探索。玩家在危机四伏的暗区中&…
阅读更多...
【软考高项】四十四、高级项目管理

【软考高项】四十四、高级项目管理

一、项目集管理 相关角色 项目集发起人、项目集指导委员会、项目集经理、其他影响项目集的干系人项目集管理绩效域 项目集战略一致性、项目集效益管理、项目集干系人参与、项目集治理和项目集生命周期管理 二、项目组合管理 项目组合经理角色 项目组合管理原…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023