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

 登神长阶

第十神装 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不仅要求理解其底层数据结构和实现原理，还需关注其在具体应用环境下的适用性和限制，通过实践不断加深理解，并灵活运用到项目开发中。

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

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

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

车载测试和传统测试有什么区别

车载测试和传统测试有什么区别

搞清楚车载测试和传统应用测试的区别,就可以大胆冲冲冲! 车载测试随着市场的需求量增加又火来一波,一直’遥遥领先’的我们一定要告诉大家一个事实:车载测试和传统的应用测试是有很大区别的. 测试对象不一样 传统测试:测试的对象无非就是各种应用,比如电脑端的web系统(使用浏…
阅读更多...
苹果电脑MAC清理系统空间工具CleanMyMacX4.15.3中文版下载

苹果电脑MAC清理系统空间工具CleanMyMacX4.15.3中文版下载

苹果电脑以其出色的性能、优雅的设计和高效的操作系统而受到许多用户的喜爱。然而&#xff0c;随着时间的推移和使用量的增加&#xff0c;你可能会发现你的Mac开始变得缓慢和响应迟缓。这通常是因为硬盘空间被大量占用&#xff0c;影响了系统的整体性能。幸运的是&#xff0c;有…
阅读更多...
树莓派遇到ping的奇葩问题解决办法

树莓派遇到ping的奇葩问题解决办法

首先&#xff0c;先 ping raspberrypi 一下。获得树莓派的ip 然后开始配置静态ip winR后输入命令ipconfig查询当前网关ip 输入命令sudo nano /etc/dhcpcd.conf 在最末尾输入以下信息 -----------------------------------------------------------------------------------…
阅读更多...
【Java EE】网络原理——TCP1

【Java EE】网络原理——TCP1

目录 1.TCP协议格式 2.TCP协议的特点 3.TCP协议的核心机制&#xff08;十个&#xff09; 3.1确认应答机制 3.2超时重传 3.3连接管理 3.3.1三次握手基本流程&#xff1a; 3.3.2三次握手的意义或者解决的问题&#xff1a;&#xff08;面试题&#xff09; 3.3.3三次握手时…
阅读更多...
32.768kHz晶振的时间精度问题及其解决方法

32.768kHz晶振的时间精度问题及其解决方法

32.768kHz晶振因其稳定性高、功耗低&#xff0c;被广泛应用于实时时钟(RTC)、计时电路及低功耗电子产品中。然而&#xff0c;在某些情况下&#xff0c;这些晶振可能出现时间偏差&#xff0c;影响设备正常工作。以下是可能导致32.768kHz晶振时间误差的原因及相应的解决策略。 温…
阅读更多...
DDD架构理论详解

DDD架构理论详解

文章目录 一、概念入门1. 概念简介2. DDD的核心理念3. 范式4. 模型5. 框架6. 方法论7. 软件设计的主要活动 二、DDD核心理论1. Domain领域层都包含什么&#xff1f;2. 聚合、实体和值对象3. 仓储&#xff0c;封装持久化数据4. 适配&#xff08;端口&#xff09;&#xff0c;调用…
阅读更多...
计算机服务器中了locked勒索病毒怎么解决，locked勒索病毒解密恢复工具

计算机服务器中了locked勒索病毒怎么解决，locked勒索病毒解密恢复工具

在网络技术飞速发展的时代&#xff0c;通过网络开展各项工作业务成为众多企业的首选&#xff0c;网络也为企业的生产运营提供了极大便利&#xff0c;大大提升了企业办公效率&#xff0c;但是利用网络避免不了网络威胁的存在&#xff0c;数据安全问题一直是企业关心的主要话题。…
阅读更多...
软件测试之 性能测试 性能测试基础指标 Loadrunner、Jmeter等工具

软件测试之 性能测试 性能测试基础指标 Loadrunner、Jmeter等工具

你好,我是Qiuner. 为记录自己编程学习过程和帮助别人少走弯路而写博客 这是我的 github gitee 如果本篇文章帮到了你 不妨点个赞吧~ 我会很高兴的 &#x1f604; (^ ~ ^) 想看更多 那就点个关注吧 我会尽力带来有趣的内容 本文档基于 https://www.bilibili.com/video/BV1wC4y1Y…
阅读更多...
AJ65SBT2B-64DA 三菱CC-Link D/A转换模块

AJ65SBT2B-64DA 三菱CC-Link D/A转换模块

AJ65SBT2B-64DA 是将数字值(16位有符号BIN数据)转换为模拟值(电压或电流)的模块。 AJ65SBT2B-64DA参数说明&#xff1a;4通道&#xff1b;输入分辨率0~12000&#xff0c;-12000~12000&#xff0c;-16000~16000&#xff1b;输出DC-10~10V&#xff0c;DC0~20mA&#xff1b;转换速…
阅读更多...
算法提高之电路维修

算法提高之电路维修

算法提高之电路维修 核心思想&#xff1a;双端队列bfs dijkstra算法的拓展情况&#xff1a;边权(旋转次数)只有0和1 dijkstra算法要求&#xff1a;每次取离原点最近的点 去更新其他相邻点距离(多次) 如何实现&#xff1a;将所有边权为0的边连的点放入队头&#xff0c;边权为1的…
阅读更多...
社交媒体数据恢复：密聊猫

社交媒体数据恢复：密聊猫

一、概述 密聊猫是一款提供多种优质体验的手机社交聊天软件。通过这款软件&#xff0c;用户可以享受到多种不同的乐趣体验&#xff0c;如真人在线匹配、真实的交友体验等。同时&#xff0c;密聊猫也提供了数据恢复功能&#xff0c;帮助用户找回丢失的数据。 二、数据恢复步骤…
阅读更多...
[算法][数组][leetcode]2391. 收集垃圾的最少总时间

[算法][数组][leetcode]2391. 收集垃圾的最少总时间

题目地址: https://leetcode.cn/problems/minimum-amount-of-time-to-collect-garbage/description/ 题解&#xff1a; class Solution {public int garbageCollection(String[] garbage, int[] travel) {int ans 0;//先计算收所有的垃圾需要多少时间for(String s :garbage){…
阅读更多...
HR人才测评，表达能力与岗位胜任力素质测评

HR人才测评，表达能力与岗位胜任力素质测评

什么是表达能力&#xff1f; 表达能力指的就是在语言能力基础之上发展形成的一种语用能力&#xff0c;可以结合自己所掌握的语言来实现交际的目的&#xff0c;能正确且灵活的把语言材料组合成为语言并且表达出想要表达的内容。 在百度百科中有如此定义&#xff0c;表达能力…
阅读更多...
软件测试用例

软件测试用例

测试用例的目的&#xff1a;为了实施测试面向测试系统提供的一组集合&#xff0c;这组集合包含&#xff1a;测试环境&#xff0c;操作步骤&#xff0c;测试数据&#xff0c;预期结果等要素 注&#xff1a;测试用例覆盖率越高&#xff0c;说明测试质量越高 测试用例覆盖率越低&…
阅读更多...
大数据测试

大数据测试

1、前言 大数据测试是对大数据应用程序的测试过程&#xff0c;以确保大数据应用程序的所有功能按预期工作。大数据测试的目标是确保大数据系统在保持性能和安全性的同时&#xff0c;平稳无差错地运行。 大数据是无法使用传统计算技术处理的大型数据集的集合。这些数据集的测试涉…
阅读更多...
codeforces round 149 div2(a,b,c,d)

codeforces round 149 div2(a,b,c,d)

手速场&#xff0c;可惜我傻逼卡 c c c了 题目链接 A #include<bits/stdc.h>using namespace std;#define int long long #define PII pair<int,int>void solve() {int n,k;cin>>n>>k;if(n<k){cout<<1<<\n;cout<<n<<\n;}…
阅读更多...
【JVM】阅读Class字节码：常量池

【JVM】阅读Class字节码：常量池

目录 基本结构解析 常量池 常量池简介 如何阅读Class文件中的常量池信息 基本结构解析 Magic(魔数) Magic的唯一作用是确定这个文件是否为一个能被虚拟机所接受的class 文件。魔数值固定为0xCAFEBABE&#xff0c;不会改变。 常量池 常量池简介 下图是反编译过后的字节码文…
阅读更多...
【机器学习】 技术栈和开发环境搭建

【机器学习】 技术栈和开发环境搭建

各位大佬好 &#xff0c;这里是阿川的博客 &#xff0c; 祝您变得更强 个人主页&#xff1a;在线OJ的阿川 大佬的支持和鼓励&#xff0c;将是我成长路上最大的动力 阿川水平有限&#xff0c;如有错误&#xff0c;欢迎大佬指正 博客目录 技术栈编程语言库框架编辑器项目IDE …
阅读更多...
Maven 的仓库、周期和插件

Maven 的仓库、周期和插件

优质博文&#xff1a;IT-BLOG-CN 一、Maven 仓库 在Maven的世界中&#xff0c;任何一个依赖、插件或者项目构建的输出&#xff0c;都可以称为构建。Maven在某个统一的位置存储所有项目的共享的构建&#xff0c;这个统一的位置&#xff0c;我们就称之为仓库。任何的构建都有唯一…
阅读更多...
【Linux】AlmaLinux 9.4版本发布

【Linux】AlmaLinux 9.4版本发布

AlmaLinux 9.4 正式版发布&#xff0c;该版本基于 Redhat Enterprise 9.4&#xff0c;内核版本号&#xff1a; 5.14.0-427.13.1.el9_4.x86_64 相对于Rocky Linux&#xff0c; AlmaLinux更加的稳定&#xff0c;生产环境建议使用AlmaLinux来替代CentOS 7.x AlmaLinux 9.4版本系统…
阅读更多...
最新文章

Copyright @ 2022~2023