HashMap底层实现原理

article/2025/11/9 12:50:50

HashMap实现原理

1.概述

HashMap是基于哈希表的Map接口的非同步实现。元素以键值对的形式存放，并且允许null键和null值，因为key值唯一（不能重复），因此，null键只有一个。另外，hashmap不保证元素存储的顺序，是一种无序的，和放入的顺序并不相同（此类不保证映射的顺序，特别是它不保证该顺序恒久不变）。HashMap是线程不安全的。

2.继承关系

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable

其中相关的属性：（JDK1.8）

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16  默认的初始容量
static final float DEFAULT_LOAD_FACTOR = 0.75f; //加载因子
static final int TREEIFY_THRESHOLD = 8; //链表长度的阈值，当超过8时，会进行树化（不绝对，如下面源码分析）
static final int UNTREEIFY_THRESHOLD = 6; //当树中只有6个或以下，转化为链表
transient int size; //HashMap的大小
int threshold; //判断是否扩容的阈值

Note：HashMap的扩容操作是一项很耗时的任务，所以如果能估算Map的容量，最好给它一个默认初始值，避免进行多次扩容。HashMap的线程是不安全的，多线程环境中推荐是ConcurrentHashMap

从下图中看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。
在这里插入图片描述

3.HashMap的数据存储结构

3.1 HashMap由数组+链表+红黑树进行数据的存储

HashMap采用table数组存储Key-Value的，每一个键值对组成了一个Node节点（JDK1.7为Entry实体，因为jdk1.8加入了红黑树，所以改为Node）。Node节点实际上是一个单向的链表结构，它具有Next指针，可以连接下一个Node节点，以此来解决Hash冲突的问题。

transient Node<K,V>[] table; //默认数组static class Node<K,V> implements Map.Entry<K,V> {final int hash;final K key;V value;Node<K,V> next;

从源码，Node就是数组中的元素，每个 Map.Entry 其实就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。

3.2 HashMap实现存储和读取

put操作

put操作所对应的实现流程如下图所示：
在这里插入图片描述

具体的源码实现如下：

//put操作
public V put(K key, V value) {return putVal(hash(key), key, value, false, true);
}//计算key对象的hash值
static final int hash(Object key) { int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//进行与操作
}//具体添加细节
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; //创建数组Node<K,V> p; //新节点int n, i;if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length; //对数组进行初始化if ((p = tab[i = (n - 1) & hash]) == null) //(n - 1) & hash 求数组的下标，判断是否有元素。没有tab[i] = newNode(hash, key, value, null);  //直接放入else { //有元素Node<K,V> e; K k;//判断存储的节点是否已存在。//1.两个对象的hash值不同，一定不是同一个对象//2.hash值相同，两个对象也不一定相等if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p; //存储的节点的key的已存在，直接进行替换else if (p instanceof TreeNode) //存储的节点的key的不存在，判断是否为树节点（是不是已经转化为红黑树）e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);else {//即不存在。也不是树节点，for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) { //直接找到链表的尾部，直接插入p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 判断链表的长度是否大于可以转化为树结构的阈值treeifyBin(tab, hash); //树化break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k)))) //判断是否和插入对象相同break;p = e;}}if (e != null) { // existing mapping for key 存在映射的key，覆盖原值，将原值返回V oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold) //hashmap的容量大于阈值resize(); //扩容afterNodeInsertion(evict);return null;}

由上面的源码可知,，当添加一个Key-Value时，我们通过hash()计算出Key所对应的hash值，然后去调用putVal（）真正的执行put操作。

  1. 首先判断数组是否为空，如果是，则进行初始化。
  2. 其次，根据**(n - 1) & hash**求出要添加对象所在的索引位置，判断此索引的内容是否为空，如果是，则直接存储，
  3. 如果不是，则判断索引位置的对象和要存储的对象是否相同，首先判断hash值知否相等，在判断key是否相等。（1.两个对象的hash值不同，一定不是同一个对象。2.hash值相同，两个对象也不一定相等）。如果是同一个对象，则直接进行覆盖，返回原值。
  4. 如果不是，则判断是否为树节点对象，如果是，直接添加
  5. 当既不是相同对象，又不是树节点，直接将其插入到链表的尾部。在进行判断是否需要进行树化。
  6. 最后，判断hashmap的size是否达到阈值，进行扩容resize()处理。

resize（）扩容操作
当hashmap中的元素越来越多的时候，碰撞的几率也就越来越高（因为数组的长度是固定的），所以为了提高效率，就要对hashmap的数组进行扩容，而在hashmap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

那么hashmap什么时候进行扩容呢？当hashmap中的元素个数超过数组大小loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，也就是说，默认情况下，数组大小为16，那么当hashmap中元素个数超过160.75=12的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知hashmap中元素的个数，那么预设元素的个数能够有效的提高hashmap的性能。

初始化和扩容的具体流程如下：
在这里插入图片描述

	final Node<K,V>[] resize() {Node<K,V>[] oldTab = table;int oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;int newCap, newThr = 0;if (oldCap > 0) {if (oldCap >= MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return oldTab;}//进行数组的扩容，长度为原来的2倍，阈值为原来的2倍else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)newThr = oldThr << 1; // double threshold}else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;**//进行数组的初始化，容量为默认值16，阈值为16*0.75**else {               // zero initial threshold signifies using defaultsnewCap = DEFAULT_INITIAL_CAPACITY;newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}if (newThr == 0) {float ft = (float)newCap * loadFactor;newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);}threshold = newThr;//把原数组的元素调整到新数组中@SuppressWarnings({"rawtypes","unchecked"})Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];table = newTab;if (oldTab != null) {for (int j = 0; j < oldCap; ++j) {Node<K,V> e;//判断当前索引j的位置是否存在元素eif ((e = oldTab[j]) != null) {oldTab[j] = null;//判断 e.next是不是有值，简而言之，就是判断当前位置是否是树或者链表if (e.next == null)//调整到新数组中newTab[e.hash & (newCap - 1)] = e;//如果是红黑树，进行树的拆分（具体不讲了）else if (e instanceof TreeNode)((TreeNode<K,V>)e).split(this, newTab, j, oldCap);//如果是链表else { // preserve orderNode<K,V> loHead = null, loTail = null;Node<K,V> hiHead = null, hiTail = null;Node<K,V> next;//遍历链表do {next = e.next;//生成低位链表if ((e.hash & oldCap) == 0) {if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;}//生成高位链表else {if (hiTail == null)hiHead = e;elsehiTail.next = e;hiTail = e;}} while ((e = next) != null);//将低位链表调整到新数组if (loTail != null) {loTail.next = null;newTab[j] = loHead;}//将高位链表调整到新数组if (hiTail != null) {hiTail.next = null;newTab[j + oldCap] = hiHead;}}}}}return newTab;}

treeifyBin操作
树化的基本操作流程如下：（不涉及左旋和右旋操作，因为不会呀）
在这里插入图片描述

final void treeifyBin(Node<K,V>[] tab, int hash) {int n, index; Node<K,V> e;//当数组的长度小于最大默认数组长度64时，进行扩容if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();else if ((e = tab[index = (n - 1) & hash]) != null) {TreeNode<K,V> hd = null, tl = null;do {//将链表节点转化为树节点，同时生成一个双向链表，因此，可以说红黑树中隐藏着一个双向链表TreeNode<K,V> p = replacementTreeNode(e, null);if (tl == null)hd = p;else {p.prev = tl;tl.next = p;}tl = p;} while ((e = e.next) != null);if ((tab[index] = hd) != null)hd.treeify(tab);}}//链表节点转化为树节点， 本质上treeNode也是双向链表，从下面的继承关系看，treeNode拥有prev和next属性。
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {return new TreeNode<>(p.hash, p.key, p.value, next);
}static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {TreeNode<K,V> parent;  // red-black tree linksTreeNode<K,V> left;TreeNode<K,V> right;TreeNode<K,V> prev;    // needed to unlink next upon deletionboolean red;
}static class Entry<K,V> extends HashMap.Node<K,V> {Entry<K,V> before, after;Entry(int hash, K key, V value, Node<K,V> next) {super(hash, key, value, next);}
}static class Node<K,V> implements Map.Entry<K,V> {final int hash;final K key;V value;Node<K,V> next;
}//树化的真正操作
final void treeify(Node<K,V>[] tab) {TreeNode<K,V> root = null;for (TreeNode<K,V> x = this, next; x != null; x = next) {next = (TreeNode<K,V>)x.next;x.left = x.right = null;//将root节点置为黑色（根据红黑树的定义）if (root == null) {x.parent = null;x.red = false;root = x;}else {K k = x.key;int h = x.hash;Class<?> kc = null;//判断插入节点在红黑树的哪边for (TreeNode<K,V> p = root;;) {int dir, ph;K pk = p.key;//小于root节点，放在左边if ((ph = p.hash) > h)dir = -1;//大于root节点，放在右边else if (ph < h)dir = 1;//等于root节点,经过下面的方法尽心过多次判断，确认是否等于else if ((kc == null &&(kc = comparableClassFor(k)) == null) ||(dir = compareComparables(kc, k, pk)) == 0)dir = tieBreakOrder(k, pk);TreeNode<K,V> xp = p;//根据dir判断放在左边还是右边if ((p = (dir <= 0) ? p.left : p.right) == null) {x.parent = xp;//放在左边（与root相等，也放在左边）if (dir <= 0)xp.left = x;//放在右边elsexp.right = x;//进行平衡操作(下面过程省略) root = balanceInsertion(root, x);break;}}}}//将隐藏的双向链表调整头结点moveRootToFront(tab, root);}

get操作

public V get(Object key) {Node<K,V> e;return (e = getNode(hash(key), key)) == null ? null : e.value;
}//计算key的hash值
static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//具体实现final Node<K,V> getNode(int hash, Object key) {Node<K,V>[] tab; Node<K,V> first, e; int n; K k;if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) { //数组不能为空并且当前索引位置的元素不能为空；如果为空，直接返回null值if (first.hash == hash && // always check first node//检查第一个元素，如果是，直接返回((k = first.key) == key || (key != null && key.equals(k))))return first;if ((e = first.next) != null) {//向下寻找if (first instanceof TreeNode)return ((TreeNode<K,V>)first).getTreeNode(hash, key);do {if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))return e;} while ((e = e.next) != null);}}return null;}

由上面的源码可知,，当通过Key获取值时，我们通过hash()计算出Key所对应的hash值，然后去调用getNode（）真正的执行get操作。

containsKey操作

public boolean containsKey(Object key) {return getNode(hash(key), key) != null;
}//计算key的hash值
static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//具体实现final Node<K,V> getNode(int hash, Object key) {Node<K,V>[] tab; Node<K,V> first, e; int n; K k;if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) { //数组不能为空并且当前索引位置的元素不能为空；如果为空，直接返回null值if (first.hash == hash && // always check first node//检查第一个元素，如果是，直接返回((k = first.key) == key || (key != null && key.equals(k))))return first;if ((e = first.next) != null) {//向下寻找if (first instanceof TreeNode)return ((TreeNode<K,V>)first).getTreeNode(hash, key);do {if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))return e;} while ((e = e.next) != null);}}return null;}

containsKey方法是先计算hash然后使用hash和table.length取摸得到index值，遍历table[index]元素查找是否包含key相同的值。

3.2 HashMap的面试相关

HashMap和Hashtable的区别

HashMap和Hashtable都实现了Map接口，。主要的区别有：

  1. 对Null key 和Null value的支持：HashMap可以接受为null的键值(key)和值(value)，Hashtable不能接受null值，会产生空指针异常。
  2. 线程是否安全： HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的
  3. 效率： 由于Hashtable是线程安全的，所以在单线程环境下比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
  4. 初始容量大小和每次扩充容量大小的不同：HashMap初始大小为16，扩容为2的幂次方；HashTable初始为11，扩容为2n+1
  5. 底层结构：HashMap会将链表长度大于阈值是转化为红黑树（会先判断当前数组的长度是否小于 64，是则扩容，而不转化），将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

HashMap 和 HashSet区别
HashSet 底层就是基于 HashMap 实现的。（HashSet的对象相当于存储在HashMap的Key上，所以保证了唯一性）
在这里插入图片描述

HashSet如何检查重复
当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用equals()方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让加入操作成功。

hashCode()与equals()的相关规定：
如果两个对象相等，则hashcode一定也是相同的
两个对象相等,对两个equals方法返回true
两个对象有相同的hashcode值，它们也不一定是相等的
综上，equals方法被覆盖过，则hashCode方法也必须被覆盖
hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。
==与equals的区别：
==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同
==是指对内存地址进行比较 equals()是对字符串的内容进行比较
==指引用是否相同 equals()指的是值是否相同

HashMap 的长度为什么是2的幂次方
为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。因此，我们首先用hash对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标 hash%tab.length。但是，当数组的长度为2的幂次方时，hash%tab.length等价于hash&(tab.lenngth-1)。（取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作）。并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。

HashMap 多线程操作导致死循环问题
当重新调整HashMap大小的时候，确实存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么就死循环了。


http://chatgpt.dhexx.cn/article/prwir2rj.shtml

相关文章

hashMap实现原理

hashMap实现原理

1. HashMap概述&#xff1a; HashMap是基于哈希表的Map接口的非同步实现&#xff08;Hashtable跟HashMap很像&#xff0c;唯一的区别是Hashtalbe中的方法是线程安全的&#xff0c;也就是同步的&#xff09;。此实现提供所有可选的映射操作&#xff0c;并允许使用null值和null键…
阅读更多...
HashMap的实现原理和底层结构

HashMap的实现原理和底层结构

哈希表&#xff08;hash table&#xff09;也叫散列表&#xff0c;是一种非常重要的数据结构&#xff0c;应用场景及其丰富&#xff0c;许多缓存技术&#xff08;比如memcached&#xff09;的核心其实就是在内存中维护一张大的哈希表&#xff0c;而HashMap的实现原理也常常出现…
阅读更多...
【java】HashMap底层实现原理

【java】HashMap底层实现原理

目录 一.哈希表(散列)1.什么是哈希表2.什么是哈希冲突(面试题)3.解决哈希冲突的方法(面试题)(1) 开放地址法① 线性探查②二次探查③随机探查 (2) 再哈希法(3) 链地址法(4)建立公共溢出区 二.HashMap1.HashMap的hash()算法(面试)(1)为什么不是h key.hashCode()直接返回&#x…
阅读更多...
HashMap底层实现原理解析

HashMap底层实现原理解析

一、HashMap底层实现原理解析 我们常见的有数据结构有三种结构&#xff1a; 数组结构链表结构哈希表结构 下面我们来看看各自的数据结构的特点&#xff1a; 1&#xff09;数组结构&#xff1a; 存储区间连续、内存占用严重、空间复杂度大 优点&#xff1a;随机读取和修改效…
阅读更多...
HashMap底层实现原理概述

HashMap底层实现原理概述

1. 前言 在一场面试中最能打动面试官的其实是细节&#xff0c;候选人对细节的了解程度决定了留给面试官的印象到底是“基础扎实”还是“基础薄弱”&#xff0c;如果候选人能够举一反三主动阐述自己对一些技术细节的理解和总结&#xff0c;那无疑是面试过程中的一大亮点。HashM…
阅读更多...
HashMap实现原理分析

HashMap实现原理分析

之前转载过一篇HashMap相关分析文章&#xff0c;快速链接&#xff1a;HashMap实现原理分析 既然有前辈已经将源码分析总结了出来&#xff0c;我们在继续学习研究源码实现的时候不妨借鉴借鉴前人的总结与经验~ 本文转自&#xff1a;https://blog.csdn.net/hefenglian/article/…
阅读更多...
HashMap面试，看这一篇就够了

HashMap面试，看这一篇就够了

历史热门文章&#xff1a; 七种方式教你在SpringBoot初始化时搞点事情 Java序列化的这三个坑千万要小心可以和面试官聊半个小时的volatile原理Java中七个潜在的内存泄露风险&#xff0c;你知道几个&#xff1f;JDK 16新特性一览啥&#xff1f;用了并行流还更慢了InnoDB自增原理…
阅读更多...
java中HashMap原理

java中HashMap原理

1、为什么用HashMap&#xff1f; HashMap是一个散列桶&#xff08;数组和链表&#xff09;&#xff0c;它存储的内容是键值对(key-value)映射HashMap采用了数组和链表的数据结构&#xff0c;能在查询和修改方便继承了数组的线性查找和链表的寻址修改HashMap是非synchronized&a…
阅读更多...
HashMap的实现原理

HashMap的实现原理

1. HashMap概述 HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作&#xff0c;并允许使用null值和null键。此类不保证映射的顺序&#xff0c;特别是它不保证该顺序恒久不变。 在java编程语言中&#xff0c;最基本的结构就是两种&#xff0c;一个…
阅读更多...
软件测试用例分析和用例设计

软件测试用例分析和用例设计

测试用例的概念 测试用例&#xff08;test case&#xff09;&#xff0c;也叫测试案例&#xff0c;是为了达到一个最佳的测试效果或者高效的发现软件中的隐藏错误&#xff08;缺陷&#xff09;而精心设计的包括场景步骤和数据。 通用的定义&#xff1a;是关于一个功能验证时候…
阅读更多...
软件测试用例设计练习

软件测试用例设计练习

1、完成163邮箱注册用例的编写 邮箱地址&#xff1a;6~18个字符&#xff0c;可使用字母、数字、下划线&#xff0c;需要以字母开头 密码&#xff1a;8~16个字符&#xff0c;大、小写字母、数字、标点符号&#xff0c;3种或以上组合 2、需求&#xff1a;输入三条边&#xff…
阅读更多...
软件测试用例详细规范

软件测试用例详细规范

软件测试用例详细规范 为什么编写测试用例详细测试用例模板测试用例字段介绍用例操作步骤用例预期结果&#xff1a; 测试用例录入原则&#xff1a;测试用例设计步骤测试用例案例&#xff1a;测试用例校验点&#xff1a; 为什么编写测试用例 我也不知道&#xff0c;自己百度 详…
阅读更多...
软件测试——测试用例设计方法

软件测试——测试用例设计方法

1、测试用例定义 测试用例又叫test case&#xff0c;是为某个特殊目标而编制的一组测试输入&#xff0c;执行条件以及预期结果&#xff0c;以便测试某个程序路径或核实是否满足某个特定需求。 2、测试用例的特性 有效性&#xff1a;测试用例能够被使用&#xff0c;且被不同人…
阅读更多...
接口测试用例怎么写？

接口测试用例怎么写？

测试流程 需求规格说明书--测试计划--测试用例--用例评审--开发 接口文档--接口分析--接口用例设计--评审--接口测试执行&#xff08;关注数据库&#xff09;--前后端对接 系统界面测试--测试结束 如何设计接口测试用例&#xff1f; 1.接口正常调用&#xff0c;先要能跑通…
阅读更多...
软件测试 - 用例篇

软件测试 - 用例篇

回顾上一篇博客主要内容:软件测试 - 基础篇 1: 软件测试的流程是什么? 需求分析,测试计划,测试设计/测试开发,测试执行,测试报告 需求分析 分析需求,验证需求的正确性和合理性,从需求中提取出测试项 测试计划 要考虑测试人数,测试环境,测试时间,测试设备等 测试设计/测试开发 …
阅读更多...
软件测试用例优先级,软件测试用例的优先级划分方法

软件测试用例优先级,软件测试用例的优先级划分方法

随着互联网的不断发展&#xff0c;程序员对于软件品质以及运行状况等参数关注程度也在提高&#xff0c;而今天我们就一起来了解一下&#xff0c;在划分测试用例优先级的时候都有哪些划分方法可以使用。 没有软件系统是完美的&#xff0c;任何系统都有BUGS。但是每一次得迭代都有…
阅读更多...
软件测试：测试用例

软件测试：测试用例

一、通用测试用例八要素　　1、用例编号&#xff1b;　　2、测试项目&#xff1b;　　3、测试标题&#xff1b;　　4、重要级别&#xff1b;　　5、预置条件&#xff1b;　　6、测试输入&#xff1b;　　7、操作步骤&#xff1b;　　8、预期输出 二、具体分析通用测试用例八要…
阅读更多...
【软件测试】测试用例的设计方法

【软件测试】测试用例的设计方法

文章目录 1. 测试用例的概念2. 设计测试用例的好处3. 基于需求设计测试用例3.1 功能性需求3.2 非功能性需求 4. 设计测试用例的具体方法4.1 等价类4.2 边界值4.3 错误猜测法4.4 场景设计法4.5 因果图法4.6 正交法 5. 测试用例的粒度 1. 测试用例的概念 测试用例就是测试人员向…
阅读更多...
如何写好测试用例

如何写好测试用例

目录 前言 为什么要写用例&#xff1f; 那怎么写好测试用例呢&#xff1f; 那么我们日常测试中&#xff0c;如果用xmind梳理用例结构注意哪些点呢&#xff1f; 结语 前言 经历过校招或社招的测试同学&#xff0c;都会被问到测试用例的设计、使用方法&#xff0c;以及用例的…
阅读更多...
软件测试——测试用例设计测试分类详解

软件测试——测试用例设计测试分类详解

文章目录 1. 测试用例的基本要素2. 测试用例的设计方法2.1 基于需求设计测试用例2.11 功能性需求测试分析2.12 非功能性需求测试分析 2.2 具体的设计测试用例的方法等价类&#xff08;非常重要&#xff09;边界值错误猜测法场景法因果图法正交法 3. 测试分类3.1 按照测试对象划…
阅读更多...
推荐文章

Copyright @ 2022~2023