淺談為什么重寫equals()就要重寫hashCode()
一、hashCode()方法
hashCode() 方法：
(1) 作用：用于判斷兩個對象是否相等；
(2) 實現：通過獲取到的哈希碼來確定該對象在哈希表中的索引位置，哈希碼也稱散列碼，實際上就是返回一個int整數；
(3) Object類：hashCode() 定義在JDK的Object.java中，這就意味著Java中的任何類都包含有hashCode() 函數，并且通過調用hashCode()方法獲取對象的hash值。
舉個例子
public class DemoTest {
public static void main(String[] args) {
Object obj = new Object();
System.out.println(obj.hashCode());
}
}
這段代碼中，obj引用就是通過調用hashCode()方法來獲取對象的hash值。
二、equals()方法
equals()方法：
(1) 作用：用于判斷兩個對象是否相等；
(2) 實現：如果對象重寫了equals()方法，重寫的比較邏輯一般是比較兩個對象的內容是否相等；如果沒有重寫，那就是比較兩個對象的地址是否相同，等價于“==”；
(3) Object類：equals()定義在JDK的Object.java中，這就意味著Java中的任何類都包含有equals()函數，并且通過調用equals()方法比較兩個引用相等，引用復制就相等，淺復制和深復制都不相等。
舉個例子
public class DemoTest {
public static void main(String[] args) {
Object obj = new Object();
System.out.println(obj.equals(obj));
}
}
這段代碼中，obj引用就是通過調用equals()方法來比較對象引用的。
三、hashCode() 與 equals()
接下面，我們討論另外一個話題——hashCode() 和 equals() 這兩個方法有什么關系？為什么重寫equals就要重寫hashcode?
3.1 不會創(chuàng)建“類對應的散列表”的情況
不會創(chuàng)建“類對應的散列表”的情況下，
(1) hashCode()：hashCode()除了打印引用所指向的對象地址看一看，沒有任何調用，重寫hashCode()邏輯也沒有用，反正沒有調用；
(2) equals()：equals()用來比較，可以自定義比較邏輯；
(3) 關系：hashCode()和equals()是兩個獨立方法，沒有任何關系，所以不存在重寫equals()要重寫hashCode()。
這里所說的“不會創(chuàng)建類對應的散列表”是說：我們不會在HashSet, HashTable, HashMap等這些本質是散列表的數據結構中使用該類作為泛型。在這種情況下，該類的“hashCode() 和 equals() ”沒有半毛錢關系。
小結：當我們不在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到這個類，此時，equals() 用來比較該類的兩個對象是否相等，而hashCode() 則根本沒有任何作用，所以，不用理會hashCode()。
舉個例子
class Main2cumtomzieEquals {
public static void main(String[] args) {
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());
}
private static class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
/**
* 重寫equals方法
*/
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
// 如果是同一個對象返回true，反之返回false
if (this == obj) {
return true; // 引用相同，返回為true
}
// 判斷是否類型相同
if (this.getClass() != obj.getClass()) {
return false; // getClass() 不相同，為false
}
Person person = (Person) obj; // 引用賦值
return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同
}
}
}
運行結果：
p1.equals(p2) : true; p1(2133927002) p2(1836019240)
p1.equals(p3) : false; p1(2133927002) p3(1625635731)
這段程序證明：對于當我們不在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到這個類作為泛型，此時，這個類的hashCode() 和 equals()沒有任何關系，在p1和p2使用equals()比較相等的情況下，hashCode()也不一定相等。
小結：不會創(chuàng)建“類對應的散列表”的情況下，
對于hashCode()：默認hashCode()僅僅返回一個int型哈希值，但是這個返回的哈希值沒卵用；
對于equals()：默認的equals)比較兩個引用是否相等，而我們自己重寫的equals用來比較兩類的屬性是否相等，因為引用賦值，所有最后兩個屬性int string一定是一樣的
Person person = (Person) obj; // 引用賦值 return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同
3.2 會創(chuàng)建“類對應的散列表”的情況
不會創(chuàng)建“類對應的散列表”的情況下，該類的“hashCode() 和 equals() ”是有關系的:
(1) 如果兩個對象相等，那么它們的hashCode()值一定相同。這里的“對象相等”是指通過equals()比較兩個對象時返回true。
(2) 如果兩個對象hashCode()相等，它們的equals()不一定相等。因為在散列表中，hashCode()相等，即兩個鍵值對的哈希值相等，然而哈希值相等，并不一定能得出鍵值對相等，此時就出現所謂的哈希沖突場景。
這里所說的“會創(chuàng)建類對應的散列表”是說：我們會在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到該類。
3.2.1 Set無法去重問題
自定義類作為HashSet的泛型，自定義類重寫equals()不重寫hashCode()，equals()的return true的范圍比hashCode() return 哈希值范圍大，導致HashSet中中出現重復元素，舉個例子，如下：
import java.util.HashSet;
class Main3cumtomizeEquals {
public static void main(String[] args) {
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
// 新建HashSet對象
HashSet<Person> set = new HashSet<>();
set.add(p1);
set.add(p2);
set.add(p3);
// 比較p1 和 p2， 并打印它們的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 打印set
System.out.printf("set:%s\n", set);
}
private static class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
/**
* 重寫equals方法,當其 name引用相同 && age引用相同 的時候就認為它相同，
*/
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
// 如果是同一個對象返回true，反之返回false
if (this == obj) {
return true; // 引用相同，返回為true
}
// 判斷是否類型相同
if (this.getClass() != obj.getClass()) {
return false; // getClass() 不相同，為false
}
Person person = (Person) obj; // 引用賦值
return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同
}
}
}
運行結果：
p1.equals(p2) : true; p1(2133927002) p2(1836019240)
set:[package1.Main3cumtomizeEquals$Person@6d6f6e28, package1.Main3cumtomizeEquals$Person@7f31245a, package1.Main3cumtomizeEquals$Person@135fbaa4]
結果分析：
問題：上面的程序中，重寫了Person的equals()，但是，HashSet中仍然有重復元素：p1 和 p2。為什么會出現這種情況呢？
回答：因為雖然p1 和 p2的內容相等，但是它們的hashCode()不等，所以，HashSet在添加p1和p2的時候，認為它們不相等，從而導致存儲HashSet存儲重復元素。
3.2.2 哈希沖突問題
自定義類作為HashSet的泛型，自定義類重寫equals()并重寫hashCode()，hashCode() return 哈希值范圍比equals() return true范圍大，造成哈希沖突，舉個例子，如下：
import java.util.HashSet;
class Main4cumtomizeEqualsAndhashcode {
public static void main(String[] args) {
// 新建Person對象
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
Person p4 = new Person("EEE", 100);
// 新建HashSet對象
HashSet<Person> set = new HashSet<>();
set.add(p1);
set.add(p2);
set.add(p3);
set.add(p4);
// 比較p1 和 p2， 并打印它們的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 比較p1 和 p4， 并打印它們的hashCode()
System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());
// 打印set
System.out.printf("set:%s\n", set);
}
private static class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
/**
* 重寫equals方法,當其 name引用相同 && age引用相同 的時候就認為它相同
*/
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
// 如果是同一個對象返回true，反之返回false
if (this == obj) {
return true; // 引用相同，返回為true
}
// 判斷是否類型相同
if (this.getClass() != obj.getClass()) {
return false; // getClass() 不相同，為false
}
Person person = (Person) obj; // 引用賦值
return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同
}
/**
* 重寫hashCode方法,邏輯為 name的哈希值^age
*/
@Override
public int hashCode() {
// 68517 ^ 100 = 68545
// 64545 ^ 200 =68545
// 68517 ^ 100 =68545
int nameHash = name.toUpperCase().hashCode();
return nameHash ^ age; // ^ 異或運算，相同為0，不同為1
}
}
}
運行結果：
p1.equals(p2) : true; p1(68545) p2(68545) //
p1.equals(p4) : false; p1(68545) p4(68545) // hashcode相等，equals不相等，這樣還是不好
set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]
結果分析：上面程序中，重寫hashCode()的同時重寫了equals()，equals()生效了，HashSet中沒有重復元素。
因為在HashSet比較p1和p2時，HashSet會發(fā)現，它們的hashCode()相等，通過equals()比較它們也返回true，所以，HashSet將p1和p2被視為相等，不會存儲多份。 同樣地，在比較p1和p4時，HashSet發(fā)現：雖然它們的hashCode()相等，但是通過equals()比較它們返回false，所以，HashSet將p1和p4被視為不相等，p1和p4各存儲一份。
3.2.3 equals()和hashCode()完全對應
上面代碼好的修改方法（讓equals和hashcode完全對應）：
/**
* 重寫equals方法,當其 name引用相同 && age引用相同 的時候就認為它相同，
*/
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
// 如果是同一個對象返回true，反之返回false
if (this == obj) {
return true; // 引用相同，返回為true
}
// 判斷是否類型相同
if (this.getClass() != obj.getClass()) {
return false; // getClass() 不相同，為false
}
Person person = (Person) obj; // 引用賦值
return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同
}
/**
* 重寫hashCode方法,邏輯為 name的哈希值^age
*/
@Override
public int hashCode() {
int nameHash = name.hashCode();
return nameHash ^ age; // ^ 異或運算，相同為0，不同為1
}
最后返回
p1.equals(p2) : true; p1(68545) p2(68545) // hashcode相等，equals相等
p1.equals(p4) : false; p1(68545) p4(68548) // hashcode不相等，equals不相等
set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]
3.2.4 進一步解釋為什么重寫equals()就要重寫hashCode()
/**
* HashSet部分
*/
public boolean add (E e){
return map.put(e, PRESENT) == null;
}
/**
* map.put方法部分
*/
public V put (K key, V value){
return putVal(hash(key), key, value, false, true);
}
/**
* putVal方法部分
*/
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) tab[i] = newNode(hash, key, value, null);
else {
Node<K, V> e;
K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;
else if (p instanceof TreeNode) 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) treeifyBin(tab, hash);
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break;
p = e;
}
}
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null) e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold) resize();
afterNodeInsertion(evict);
return null;
}
由上面HashSet源碼可知，HashSet使用的是HashMap的put方法，而hashMap的put方法，使用hashCode()用key作為參數計算出hash值，然后進行比較，如果相同，再通過equals()比較key值是否相同，如果相同，返回同一個對象。
所以，如果類使用再散列表的集合對象中，要判斷兩個對象是否相同，除了要覆蓋equals()之外，也要覆蓋hashCode()函數，否則，equals()無效。
所以，在HashSet中，一定要同時重寫hashCode()和equals()，HashSet底層是由于HashMap的數據結構（數組+鏈表/紅黑樹）的比較邏輯決定的。
四、重寫hashCode()的目標
理論上，一個好的hashCode的方法的目標：為不相等的對象（equals為false）產生不相等的散列碼，而相等的對象（equals為true）必須擁有相等的散列碼。
即equals和hashcode對應，向默認的那樣，既不會出現hashcode相等，equals不相等的哈希沖突，也不會出現equals相等，hashcode不相等造成HashSet存放equals為true的元素。
實際上，一般來說，hashcode相等，equals不相等的哈希沖突還能忍受，但是equals相等造成hashcode不相等，造成HashSet存放相同是一定不能忍受的，就是說，重寫equals放寬return true的同時一定要重寫hashcode放寬return 哈希碼。
以下驗證本文中心問題：
(1) 把某個非零的常數值，比如17，保存在一個int型的result中。
(2) 對于每個關鍵域f（equals方法中設計到的每個域），為該域計算int類型的散列碼，并
① 如果該域是boolean類型，則計算(f?1:0)；
② 如果該域是byte,char,short或者int類型,計算(int)f；
③ 如果是long類型，計算(int)(f^(f>>>32))；
④ 如果是float類型，計算Float.floatToIntBits(f)；
⑤ 如果是double類型，計算Double.doubleToLongBits(f),然后再計算long型的hash值；
⑥ 如果是對象引用，則遞歸的調用域的hashCode，如果是更復雜的比較，則需要為這個域計算一個范式，然后針對范式調用hashCode，如果為null，返回0；
⑦ 如果是一個數組，則把每一個元素當成一個單獨的域來處理。
(3) 執(zhí)行result = 31 * result + name.hashcode()，并返回result。
(4) 編寫單元測試驗證有沒有實現所有相等的實例都有相等的散列碼。
給個簡單的例子（一個好的hashCode()的使用）：
@Overridepublic int hashCode() {
int result = 17;
result = 31 * result + name.hashCode();
return result;
}
這里再說下2.b中為什么采用31*result + c,乘法使hash值依賴于域的順序，如果沒有乘法那么所有順序不同的字符串String對象都會有一樣的hash值，而31是一個奇素數，如果是偶數，并且乘法溢出的話，信息會丟失，31有個很好的特性是31*i ==(i<<5)-i,即2的5次方減1，虛擬機會優(yōu)化乘法操作為移位操作的。
五、面試金手指
5.1 為什么重寫equals()一定要重寫hashCode()
5.1.1 不會創(chuàng)建“類對應的散列表”的情況
當我們不在HashSet, HashTable, HashMap等這些本質是散列表的數據結構中，用到這個類作為泛型，此時，這個類的hashCode() 和 equals()沒有任何關系；
equals()方法
(1) 作用： equals() 用來比較該類的兩個對象是否相等。
(2) 實現：equals未被重寫就直接進行引用比較，源碼如下：
public boolean equals(Object obj) {
return (this == obj);
}
若equals已被重寫，就按照自己的重寫equals邏輯來。
hashCode()：默認的hashcode()就是返回哈希值，但是此時返回的哈希值根本沒有任何作用，不用理會hashCode()。
當我們不在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中，用到這個類作為泛型，這種情況下，
(1) 不重寫equals，不重寫hashCode()
equals直接比較引用，hashCode()也是直接返回對象地址， 所以，equals()與hashCode()完全對應，即對于兩個引用：
① equals為true，hashCode()一定相等；
② equals為false，hashCode()一定不相等；
③ hashCode()相等，equals一定為true；
④ hashCode()不相等，equals一定為false。
(2) 重寫equals()為比較對象的屬性，不重寫hashCode()
① 如果equals()相等，表示兩個引用相等或兩個引用指向的對象各個屬性(基本類型+String)相等，hashcode()不一定相等（理由：因為一定要兩個引用相等，指向的對象地址才相等）。
② 如果hashCode()相等，表示兩個引用指向的對象哈希地址相等，則引用相等（因為哈對象哈希地址是任意分配的），equals()一定相等（未重寫比較引用相等，已重寫）。
③ 如果equals不相等，表示兩個引用一定不相等，hashcode()兩個引用所指向的對象地址一定不相等（因為哈希地址隨機分配）。
④ 如果hashcode不相等，兩個引用指向的對象地址不相等，equals()可以相等，可以不相等。
小結：不能說明equals()和hashCode()有關系，只是因為重寫equals()把return true;的條件放寬了，只要兩個引用指向的對象中屬性相等就好，不一定引用相等，但是hashCode()還是返回對象地址。
5.1.2 創(chuàng)建“類對應的散列表”的情況下
當我們在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中，用到這個類，就是這個類作為集合框架的泛型，此時，這個類的hashCode() 和 equals()緊密相關；因為這些散列表數據結構，對其泛型，要求兩個引用所指向的對象hashCode() 和 equals()均相同，才認為是同一個對象。
(1) 重寫equals()為比較對象的屬性，不重寫hashCode()
equals()相等，hashcode()可以不相等：HashSet中放入兩個相同就有相同屬性的Person對象，兩個Person對象屬性相同，所以equals比較兩個引用得到的結果相等，但是底層指向不同的對象地址，因此hashcode不相等，則HashSet在添加p1和p2的時候認為它們不相等，所以，HashSet中仍然有重復元素：p1 和 p2。
這說明默認的hashcode()不夠好，一個好的哈希算法不應該讓HashSet中有重復元素。因為要對應equals()的判斷為true要和hashCode()的判斷完全對應，默認的equals()和hashCode()就是比較引用和對象地址的，我們重寫的equals()和hashCode()，是比較引用所指向的對象的個數屬性的，總之，equals()和hashCode()要一一對應，所以重寫equals()就要重寫hashCode()。
(2) 重寫equals為比較對象的屬性，并且重寫hashCode()
重寫的equals()：兩個引用相等或者兩個引用所指向的對象的屬性相等，返回true，其余返回為false。
重寫的hashCode()： name的哈希值^age，異或運算，相同為0，不同為1。
重寫equals并且重寫hashCode()，三種情況如下：
① equals相等，hashcode()不相等：HashSet集合中的內容相同的元素(這就是重寫equals不重寫hashcode帶來的問題);
② equals相等，hashcode()相等：完全對應;
③ hashCode()相等，equals不相等：HashMap中的哈希沖突.
在完全對應的情況下，在HashSet看來：比較p1和p2，它們的hashCode()相等，通過equals()比較它們也返回true，所以p1和p2被視為相等；比較p1和p4，雖然它們的hashCode()相等；但是，通過equals()比較它們返回false，p1和p4被視為不相等。
小結：
(1) 不會創(chuàng)建“類對應的散列表”，hashcode除了打印引用所指向的對象地址看一看，沒有任何調用，重寫hashcode邏輯也沒有用，反正沒有調用，equals用來比較，可以自定義比較邏輯，hashcode和equals是兩個獨立方法，沒有任何關系，不存在重寫equals要重寫hashcode。
(2) 當我們在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中，用到這個類，就是這個類作為集合框架的泛型，此時，這個類的hashCode() 和 equals()緊密相關，因為這些散列表數據結構，對其泛型，要求兩個引用所指向的對象hashCode() 和 equals()均相同，才認為是同一個對象。
5.2 hashCode()底層實現，一個好的哈希算法
理論上，一個好的hashCode的方法的目標：為不相等的對象（equals為false）產生不相等的散列碼，同樣的，相等的對象（equals為true）必須擁有相等的散列碼，即equals和hashcode對應，向默認的那樣，既不會出現hashcode相等，equals不相等的哈希沖突，也不會出現equals相等，hashcode不相等造成HashSet存放equals為true的元素。
實踐上，一般來說，hashcode相等，equals不相等的哈希沖突還能忍受，但是equals相等造成hashcode不相等，造成HashSet存放相同是一定不能忍受的，就是說，重寫equals放寬return true;一定要重寫hashcode放寬return 哈希碼，驗證本文中心問題，一定要hashcode范圍和equals范圍一樣大，不能保證的化，就讓hashcode范圍比equals范圍大，允許哈希沖突不允許HashSet存放重復元素。
六、尾聲
為什么重寫equals()就要重寫hashCode()，完成了。
源代碼工程地址：hashcode-equals_jb51.rar
到此這篇關于淺談為什么重寫equals()就要重寫hashCode()的文章就介紹到這了,更多相關重寫equals()就要重寫hashCode()內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家詳細介紹了java模擬簡單的tomcat的方法，使用數據庫，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-02-02
這篇文章主要介紹了Java 在Word文檔中添加藝術字的示例，幫助大家使用Java處理word文檔，感興趣的朋友可以了解下2020-09-09
下面小編就為大家?guī)硪黄斦凧ava泛型中T和問號(通配符)的區(qū)別。小編覺得挺不錯的，現在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-10-10
Java隨手筆記8之包、環(huán)境變量和訪問控制及maven profile實現多環(huán)境打包
這篇文章主要介紹了Java隨手筆記8之包、環(huán)境變量和訪問控制及maven profile實現多環(huán)境打包的相關資料,需要的朋友可以參考下2015-11-11
這篇文章主要介紹了java泛型常用通配符實例解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-01-01
這篇文章主要為大家詳細介紹了java使用DOM4J對XML文件進行增刪改查操作，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-12-12
MyBatis解決Update動態(tài)SQL逗號的問題
這篇文章主要介紹了MyBatis解決Update動態(tài)SQL逗號的問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-01-01
本文主要介紹了SpringBoot?熱搜與不雅文字過濾的實現，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-07-07
這篇文章主要介紹了使用idea2017搭建SSM框架(圖文步驟)，小編覺得挺不錯的，現在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-12-12
這篇文章主要為大家詳細介紹了Java通過exchange協議發(fā)送郵件，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-02-02