दिलचस्प पोस्ट
टीएसक्यूएल: स्थानीय समय को यूटीसी में कनवर्ट कैसे करें? (SQL सर्वर 2008) मैं NSString मान को NSData में कैसे रूपांतरित करूं? लिनक्स के साथ यूएसबी पावर सप्लाई (चालू / बंद) को नियंत्रित करना ओरेकल एसक्यूएल डेवलपर में मैं चर का उपयोग कैसे करूं? मिसाम और इंनोडीबी के बीच क्या अंतर है? <Div> अंदर <लेबल> ब्लॉक सही है? एक्सेस प्रतिबंध: प्रकार 'अनुप्रयोग' एपीआई नहीं है (आवश्यक पुस्तकालय आरटी.जर पर प्रतिबंध) कनेक्शन का समय समाप्त। क्यूं कर? जावास्क्रिप्ट नोडलिस्ट मैं एक शेल स्क्रिप्ट में उड़ने पर नए चर नाम कैसे बना सकता हूं? स्वचालित कुकी हैंडलिंग सी # /। नेट एचटीटीपी वेबबर्वाइट + एचटीटीपी वेब रिस्पॉन्स ऐप को चालू होने के दौरान एंड्रॉइड स्क्रीन का समय समाप्त हो गया है कलेक्शंस मॉड्यूल पायथन में काउंटर मेरा संकेत / स्लॉट कनेक्शन काम नहीं करता है PHP URL से चित्र सहेज रहा है

एक हैशमैप में बराबर और हैशोड के कामकाज को समझना

मेरे पास यह परीक्षण कोड है:

import java.util.*; class MapEQ { public static void main(String[] args) { Map<ToDos, String> m = new HashMap<ToDos, String>(); ToDos t1 = new ToDos("Monday"); ToDos t2 = new ToDos("Monday"); ToDos t3 = new ToDos("Tuesday"); m.put(t1, "doLaundry"); m.put(t2, "payBills"); m.put(t3, "cleanAttic"); System.out.println(m.size()); } } class ToDos{ String day; ToDos(String d) { day = d; } public boolean equals(Object o) { return ((ToDos)o).day == this.day; } // public int hashCode() { return 9; } } 

जब // public int hashCode() { return 9; } // public int hashCode() { return 9; } uncommented m.size() रिटर्न 2, जब यह टिप्पणी छोड़ दिया है यह तीन देता है। क्यूं कर?

Solutions Collecting From Web of "एक हैशमैप में बराबर और हैशोड के कामकाज को समझना"

आपने ओवरहेडिंग हैशोडोड बिना ओवरहेड होने के equals आपको यह सुनिश्चित करना चाहिए कि सभी मामलों में जहां दो ऑब्जेक्ट के लिए equals रिटर्न मिलता है, hashCode वही मान देता है। हैश कोड एक ऐसा कोड है जिसे बराबर होना चाहिए, यदि दो ऑब्जेक्ट समान हैं (कन्वर्ज़ की ज़रूरत नहीं है)। जब आप 9 में अपनी हार्ड-कोडेड वैल्यू डालते हैं, तो आप फिर से अनुबंध को संतुष्ट करते हैं

आपके हैश मैप में, समानता का केवल एक हैश बाल्टी के भीतर परीक्षण किया जाता है। आपके दो सोमवार वस्तुएं बराबर होनी चाहिए, लेकिन क्योंकि वे विभिन्न हैश कोड वापस कर रहे हैं, उनकी समानता को निर्धारित करने के लिए equals विधि भी नहीं बुलाया जाता है – उन्हें अलग-अलग बाल्टी में सीधे रखा जाता है, और संभावना है कि वे समान नहीं हैं ।

HashMap प्रवेश खोज के लिए hashCode() , == और equals() का उपयोग करता है दिए गए कुंजी के लिए लुकअप अनुक्रम निम्नानुसार है:

  • का उपयोग करें k.hashCode() निर्धारित करने के लिए कि कौन सा बाल्टी प्रविष्टि संग्रहीत है, यदि कोई हो
  • यदि पाया जाता है, तो उस बाल्टी में प्रत्येक प्रविष्टि की कुंजी के लिए, अगर k == k1 || k.equals(k1) k == k1 || k.equals(k1) , फिर k1 का प्रवेश वापस करें
  • कोई अन्य परिणाम, कोई संबंधित प्रविष्टि नहीं

एक उदाहरण का उपयोग करने के लिए, मान लें कि हम एक HashMap बनाना चाहते हैं जहां कुंजी कुछ हैं जो 'तार्किक रूप से समतुल्य' हैं यदि उनके पास एक ही पूर्णांक मान है, जो कि AmbiguousInteger क्लास द्वारा दर्शाया गया है। फिर हम एक HashMap निर्माण करते हैं, एक प्रविष्टि में डालते हैं, फिर इसके मान को ओवरराइड करने का प्रयास करते हैं और कुंजी द्वारा मूल्य पुनः प्राप्त करते हैं।

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } } HashMap<AmbiguousInteger, Integer> map = new HashMap<>(); // logically equivalent keys AmbiguousInteger key1 = new AmbiguousInteger(1), key2 = new AmbiguousInteger(1), key3 = new AmbiguousInteger(1); map.put(key1, 1); // put in value for entry '1' map.put(key2, 2); // attempt to override value for entry '1' System.out.println(map.get(key1)); System.out.println(map.get(key2)); System.out.println(map.get(key3)); Expected: 2, 2, 2 

hashCode() और equals() ओवरराइड न करें : डिफ़ॉल्ट रूप से जावा अलग-अलग ऑब्जेक्ट्स के लिए अलग key1 hashCode() मान बनाता है, इसलिए key1 और की key2 को अलग-अलग बाल्टी में मैप करने के लिए इन मानों का उपयोग करता है। key3 में कोई बाल्टी नहीं है, इसलिए इसका कोई मूल्य नहीं है।

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 2, set as entry 2[1] map.get(key1); // map to bucket 1, get as entry 1[1] map.get(key2); // map to bucket 2, get as entry 2[1] map.get(key3); // map to no bucket Expected: 2, 2, 2 Output: 1, 2, null 

key1 hashCode() केवल: key1 मानचित्र key1 और key2 उसी बाल्टी में है, लेकिन वे दोनों key1 == key2 और key1.equals(key2) चेक के कारण भिन्न प्रविष्टियां बनी रहती हैं, क्योंकि डिफ़ॉल्ट रूप से equals() == जांच का उपयोग करता है, और वे विभिन्न उदाहरणों का उल्लेख करते हैं key3 विफल दोनों == और equals() key1 और key2 खिलाफ जांच करता है और इस प्रकार कोई संगत मूल्य नहीं है।

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } @Override public int hashCode() { return value; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 1, set as entry 1[2] map.get(key1); // map to bucket 1, get as entry 1[1] map.get(key2); // map to bucket 1, get as entry 1[2] map.get(key3); // map to bucket 1, no corresponding entry Expected: 2, 2, 2 Output: 1, 2, null 

ओवरराइड equals() केवल equals() : डिफ़ॉल्ट रूप से भिन्न hashCode() की वजह से HashMap सभी चाबियाँ विभिन्न बाल्टी में मैप करता है। == या equals() चेक यहां अप्रासंगिक है क्योंकि HashMap उस बिंदु तक नहीं पहुंचता जहां उसे उपयोग करने की आवश्यकता होती है।

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } @Override public boolean equals(Object obj) { return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 2, set as entry 2[1] map.get(key1); // map to bucket 1, get as entry 1[1] map.get(key2); // map to bucket 2, get as entry 2[1] map.get(key3); // map to no bucket Expected: 2, 2, 2 Actual: 1, 2, null 

दोनों hashCode() और equals() ओवरराइड करें : key1 मानचित्र key1 , key2 और एक ही बाल्टी में key3== चेक विभिन्न उदाहरणों की तुलना करते समय असफल होते हैं, लेकिन equals() चेक पास होते हैं क्योंकि वे सभी एक ही मान देते हैं, और हमारे तर्क द्वारा 'तर्कसंगत समतुल्य' मानते हैं।

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } @Override public int hashCode() { return value; } @Override public boolean equals(Object obj) { return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 1, set as entry 1[1], override value map.get(key1); // map to bucket 1, get as entry 1[1] map.get(key2); // map to bucket 1, get as entry 1[1] map.get(key3); // map to bucket 1, get as entry 1[1] Expected: 2, 2, 2 Actual: 2, 2, 2 

क्या hashCode() बेतरतीब है? : HashMap प्रत्येक ऑपरेशन के लिए एक अलग बाल्टी प्रदान करेगा, और इस तरह आप पहले से ही उसी प्रविष्टि को नहीं खोज पाएंगे जो आपने पहले किया था।

 class AmbiguousInteger { private static int staticInt; private final int value; AmbiguousInteger(int value) { this.value = value; } @Override public int hashCode() { return ++staticInt; // every subsequent call gets different value } @Override public boolean equals(Object obj) { return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 2, set as entry 2[1] map.get(key1); // map to no bucket, no corresponding value map.get(key2); // map to no bucket, no corresponding value map.get(key3); // map to no bucket, no corresponding value Expected: 2, 2, 2 Actual: null, null, null 

क्या hashCode() हमेशा एक ही है? : HashMap सभी चाबियाँ एक बड़ी बाल्टी में HashMap इस स्थिति में, आपका कोड कार्यात्मक रूप से सही है, लेकिन HashMap का उपयोग व्यावहारिक रूप से बेमानी है, क्योंकि किसी भी पुनर्प्राप्ति को ओ (एन) समय ( या ओ 8 के लिए ओ ओ (लॉगएन)) में उस एकल बाल्टी में सभी प्रविष्टियों के माध्यम से दोहराया जाना आवश्यक है , एक List के उपयोग के बराबर

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } @Override public int hashCode() { return 0; } @Override public boolean equals(Object obj) { return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 1, set as entry 1[1] map.get(key1); // map to bucket 1, get as entry 1[1] map.get(key2); // map to bucket 1, get as entry 1[1] map.get(key3); // map to bucket 1, get as entry 1[1] Expected: 2, 2, 2 Actual: 2, 2, 2 

और अगर equals हमेशा झूठा होता है? : == चेक उत्तीर्ण हो जाता है जब हम उसी उदाहरण की स्वयं की तुलना करते हैं, लेकिन अन्यथा असफल हो जाता है, equals जांच हमेशा असफल हो key1 , इसलिए key1 , key2 और key3 'तार्किक रूप से भिन्न' मानी जाती है, और विभिन्न प्रविष्टियों के लिए नक्शे, हालांकि वे अभी भी समान हैं उसी hashCode() कारण बाल्टी

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } @Override public int hashCode() { return 0; } @Override public boolean equals(Object obj) { return false; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 1, set as entry 1[2] map.get(key1); // map to bucket 1, get as entry 1[1] map.get(key2); // map to bucket 1, get as entry 1[2] map.get(key3); // map to bucket 1, no corresponding entry Expected: 2, 2, 2 Actual: 1, 2, null 

ठीक है कि अगर equals हमेशा सही होता है? : आप मूल रूप से कह रहे हैं कि सभी वस्तुओं को 'तर्कसंगत रूप से समतुल्य' समझा जाता है, इसलिए वे सभी एक ही बाल्टी के लिए मानचित्र (उसी hashCode() ), एक ही प्रविष्टि।

 class AmbiguousInteger { private final int value; AmbiguousInteger(int value) { this.value = value; } @Override public int hashCode() { return 0; } @Override public boolean equals(Object obj) { return true; } } map.put(key1, 1); // map to bucket 1, set as entry 1[1] map.put(key2, 2); // map to bucket 1, set as entry 1[1], override value map.put(new AmbiguousInteger(100), 100); // map to bucket 1, set as entry1[1], override value map.get(key1); // map to bucket 1, get as entry 1[1] map.get(key2); // map to bucket 1, get as entry 1[1] map.get(key3); // map to bucket 1, get as entry 1[1] Expected: 2, 2, 2 Actual: 100, 100, 100 

जब आप हैशोड () विधि को ओवरराइड नहीं करते हैं, तो आपकी ToDos वर्ग ऑब्जेक्ट से डिफ़ॉल्ट हैशोड () विधि को प्राप्त करता है, जो प्रत्येक ऑब्जेक्ट को एक अलग हैश कोड देता है। इसका अर्थ है कि t1 और t1 2 के पास दो अलग-अलग हैश कोड हैं, भले ही आप उनकी तुलना करें, वे समान होंगे। विशेष रूप से हैशप कार्यान्वयन के आधार पर, नक्शा उन्हें अलग से स्टोर करने के लिए स्वतंत्र है (और यह वास्तव में क्या होता है)।

जब आप सही तरीके से हैश कोड () पद्धति को ओवरराइड करते हैं तो यह सुनिश्चित करने के लिए कि समान वस्तु बराबर हैश कोड प्राप्त करते हैं, हैशप दो समान वस्तुओं को ढूंढने में सक्षम है और उन्हें एक ही हैश बाल्टी में रखता है।

एक बेहतर क्रियान्वयन उन वस्तुओं को देगी जो समान हैश कोड के समान नहीं हैं, जैसे:

 public int hashCode() { return (day != null) ? day.hashCode() : 0; } 

मैं पर्याप्त रूप से ज़ोर नहीं दे सकता कि आपको प्रभावी जावा (चेतावनी: पीडीएफ लिंक) में अध्याय 3 पढ़ना चाहिए। उस अध्याय में आप Object में ओवरराइड करने के तरीके, और विशेष रूप से equals अनुबंध के बारे में जानने के लिए आवश्यक सभी चीज़ें सीखेंगे। जोश ब्लाच में एक equals विधि को ओवरराइड करने के लिए एक महान नुस्खा है, जिसे आप का पालन करना चाहिए। और यह आपको समझने में मदद करेगा कि आप अपने equals विधि के विशिष्ट कार्यान्वयन में equals का उपयोग क्यों नहीं करना चाहिए और नहीं ==

उम्मीद है की यह मदद करेगा। कृपया इसे पढ़ें। (कम से कम पहले कुछ आइटम … और फिर आप बाकी को पढ़ना चाहते हैं :-)।

टॉम

जब आप टिप्पणी करते हैं, तो यह 3 देता है;

क्योंकि ऑब्जेक्ट से विरासत में मिली हैशोड () को केवल कहा जाता है जो 3 टूडोस ऑब्जेक्ट्स के लिए 3 अलग हैश कोड देता है। असमान हैशोड्स का मतलब है कि 3 ऑब्जेक्ट्स अलग-अलग बाल्टी के लिए नियत हैं और बराबर () वापसी झूठी हैं क्योंकि वे अपने संबंधित बाल्ट्स में पहली प्रवेशक हैं। यदि हैशकोड अलग हैं तो यह पहले से समझा जाता है कि वस्तुओं असमान हैं वे विभिन्न बाल्टी में जाएंगे

जब आप असंबद्ध करते हैं, तो यह 2 देता है;

क्योंकि यहां अधिरोहित हैशोड () कहा जाता है जो सभी टूडोस के लिए समान मूल्य देता है और उन सभी को एक बाल्टी में जाना होगा, जो कि लाइनरीली से जुड़ा होगा। बराबर हैशोडॉड्स ऑब्जेक्ट की समानता या असमानता के बारे में कुछ भी न वादा नहीं करते हैं।

टी 3 के लिए हैशडोड () 9 है और चूंकि यह पहला प्रवेशकर्ता है, बराबर () झूठा है और बाल्टी में टी 3 डाला जाता है- बाल्टी कहें।

तब टी 2 उसी हैशोड () के रूप में 9 को उसी बाल्टी0 के लिए नियत किया जाता है, बाद में टी 3 में रहने वाले टी 3 में बराबर बराबर होता है (ओवरराइड बराबर) की परिभाषा द्वारा गलत है

अब हैशकोड (9) के साथ टी 1 भी बाल्टी0 के लिए किस्मत में है, और एक समान बाल्टी में पहले से मौजूद टी 2 के मुकाबले तुलना में एक बराबर () कॉल रिटर्न सही होता है। मानचित्र में प्रवेश करने में टी 1 विफल रहता है तो नक्शा का शुद्ध आकार 2 है -> {ToDos @ 9 = स्वच्छ ऐटेटिक, टूडो @ 9 = पेफिल)

यह समतुल्य () और हैशोड () दोनों को कार्यान्वित करने के महत्व को बताता है, और इस तरह से हैशकोड () का निर्धारण करते समय भी समानता निर्धारित करने में खेतों को लिया जाना चाहिए। इससे यह गारंटी होगी कि यदि दो ऑब्जेक्ट बराबर हैं, तो वे हमेशा ही हैशटोड होंगे। हैशकोड को छद्म-यादृच्छिक संख्या के रूप में नहीं माना जाना चाहिए क्योंकि वे बराबर () के अनुरूप होना चाहिए

प्रभावी जावा के अनुसार,

हमेशा हाशोड ओवरराइड करें () जब आप बराबर ओवरराइड करते हैं ()

क्यों? सरल, क्योंकि विभिन्न ऑब्जेक्ट्स (सामग्री, संदर्भ नहीं) को अलग-अलग हैश कोड मिलना चाहिए; दूसरी ओर, समान वस्तुओं को एक ही हैश कोड मिलना चाहिए।

उपरोक्त के अनुसार, जावा एसोसिएटिव डेटा स्ट्रक्चर बाल्टियों को बनाने के लिए बराबर () और हैशोड () इनवॉकेशन द्वारा प्राप्त परिणामों की तुलना करते हैं। यदि दोनों समान हैं, तो वस्तुएं बराबर होती हैं; अन्यथा नहीं

विशिष्ट मामले में (जो कि ऊपर प्रस्तुत किया गया है), जब हैशोड () की टिप्पणी की जाती है , तो प्रत्येक उदाहरण (ऑब्जेक्ट द्वारा प्राप्त होने वाले व्यवहार) के लिए एक यादृच्छिक संख्या उत्पन्न होती है, जैसा हैश, बराबर () चेक स्ट्रिंग का संदर्भ (जावा स्ट्रिंग पूल याद है), इसलिए बराबर () को सही करना चाहिए, लेकिन हैशोड () नहीं, परिणाम 3 अलग-अलग ऑब्जेक्ट्स संग्रहीत हैं । देखते हैं कि क्या हुआ हैकोड () अनुबंध का सम्मान करते हुए लेकिन हमेशा 9 लौट रहा है। खैर, हैशोड () लगातार एक ही है, पूल (यानी "सोमवार") में दो स्ट्रिंग्स के बराबर बराबर () रिटर्न देता है , और उनके लिए बाल्टी समान हो जाएगी, जिसके परिणामस्वरूप केवल 2 तत्वों को संग्रहित किया जाएगा

इसलिए, हैश कोड () और बराबर () ओवरराइड का उपयोग करने में निश्चित रूप से सावधान रहना आवश्यक है, खासकर जब यौगिक डेटा प्रकार उपयोगकर्ता परिभाषित होते हैं और उनका उपयोग जावा एसोसिएटिव डेटा संरचनाओं के साथ किया जाता है

जब हैशोड को असंपीम किया जाता है, तो हैशमैक्स टी 1 और टी 2 को उसी चीज़ के रूप में देखता है; इस प्रकार, टी 2 के टी 2 के मूल्य के थक्के यह कैसे काम करता है यह समझने के लिए, ध्यान दें कि जब हैशोड दो उदाहरणों के लिए एक ही बात लौटाता है, तो वे उसी हैशमैप बाल्टी पर जाते हैं। जब आप एक ही बाल्टी में दूसरी चीज डालने की कोशिश करते हैं (इस मामले में टी 2 को तब सम्मिलित किया जा रहा है जब टी 1 पहले से मौजूद है), हैशमैप एक अन्य कुंजी के लिए बाल्टी को स्कैन करता है जो बराबर है। आपके मामले में, टी 1 और टी 2 बराबर हैं क्योंकि उनके पास उसी दिन है। उस वक्त, "पेबिल्स" क्लॉबर्स "डोलड्री" के लिए कि क्या टी 2 clobbers टी 1 कुंजी के रूप में, मेरा मानना ​​है कि यह अपरिभाषित है; इस प्रकार, या तो व्यवहार की अनुमति है

यहां पर विचार करने के लिए कुछ महत्वपूर्ण चीजें हैं:

  1. क्या दो टूडो उदाहरण वास्तव में बराबर हैं क्योंकि उनके पास सप्ताह का एक ही दिन है?
  2. जब भी आप बराबर कार्यान्वित करते हैं, आपको हैशोड को कार्यान्वित करना चाहिए ताकि किसी भी दो ऑब्जेक्ट्स के बराबर हो जाएं, जो कि समान हैश कोड मान है। यह मूलभूत धारणा है कि हैशमैप बनाता है संभवतया यह कुछ भी सच है जो हैश कोड विधि को निर्भर करता है।
  3. अपने हैश कोड विधि को डिज़ाइन करें ताकि हैश कोड को समान रूप से वितरित किया जा सके; अन्यथा, आपको हैशिंग का प्रदर्शन लाभ नहीं मिलेगा। इस परिप्रेक्ष्य से, 9 लौटने की सबसे खराब चीजें हैं जो आप कर सकते हैं।

हैश-कोड के रूप में हैश-बैट मैपिंग के संदर्भ में सोचने के बजाय, मुझे लगता है कि यह कुछ और अधिक समान रूप से सोचने में सहायक होता है: एक अवलोकन है कि दो ऑब्जेक्ट्स के पास अलग-अलग हैश कोड हैं, जो एक अवलोकन का गठन करता है कि ऑब्जेक्ट समान नहीं हैं इसका एक परिणाम के रूप में, यह एक अवलोकन है कि संग्रह में मौजूद वस्तुओं में से कोई भी एक विशेष हेश कोड नहीं है, यह एक अवलोकन है कि संग्रह में मौजूद वस्तुओं में से कोई भी किसी भी ऑब्जेक्ट के बराबर नहीं है जो कि हैश कोड है। इसके अलावा, एक अवलोकन यह है कि संग्रह में मौजूद वस्तुओं में से कोई भी एक हैश कोड नहीं है जिसमें कोई विशेषता है कि वे किसी भी ऑब्जेक्ट के बराबर नहीं हैं।

हेश टेबल आम तौर पर लक्षणों के परिवार को परिभाषित करते हुए काम करते हैं, जिनमें से प्रत्येक में प्रत्येक ऑब्जेक्ट के हैश कोड पर लागू होता है (जैसे "1 47 के अनुरूप होना," "1 मोड 47 के अनुरूप होना" आदि) और फिर प्रत्येक विशेषता के साथ वस्तुओं का एक संग्रह है अगर किसी को एक वस्तु दी जाती है और यह निर्धारित कर सकता है कि उस पर कौन से विशेषता लागू होती है, तो एक यह जान सकता है कि उस विशेषता के साथ चीजों के संग्रह में होना आवश्यक है।

वह हेश टेबल आम तौर पर संख्याबद्ध बाल्टी के अनुक्रम का उपयोग एक कार्यान्वयन विवरण है; क्या जरूरी है कि ऑब्जेक्ट के हैश कोड को बहुत सी चीजों की पहचान करने के लिए जल्दी उपयोग किया जाता है जो संभवतः इसके बराबर नहीं हो सकता है, और जिसके साथ इसे तुलना करने की आवश्यकता नहीं होगी।

जब भी आप जावा में एक नया ऑब्जेक्ट बनाते हैं, तो उसे स्वयं ही जेवीएम द्वारा एक अद्वितीय हैशोड असाइन किया जाएगा। यदि आप हैशोड विधि को ओवरराइड नहीं करेंगे तो ऑब्जेक्ट को अद्वितीय हैकोड मिल जाएगा और इसलिए एक अनूठी बाल्टी (इमेजिन बाल्टी मेमोरी में एक जगह है, जहां पर जेवीएम ऑब्जेक्ट ढूंढने के लिए जाएंगे)।

(आप प्रत्येक ऑब्जेक्ट पर हैशोड विधि को कॉल करके और कंसोल पर उनके मूल्यों को मुद्रित करके हैशोड की विशिष्टता देख सकते हैं)

आपके मामले में जब आप हैश कोड विधि टिप्पणी कर रहे हैं, तो हैशप सबसे पहले बाइट की तलाश में हैश कोड वाले पद्धति का रिटर्न देता है। और हर बार आप उसी हैशोड को वापस कर रहे हैं अब जब हैशप उस बाल्टी को पाता है, तो यह मौजूदा ऑब्जेक्ट की तुलना इक्वलल विधि का उपयोग करके बाल्टी में रहने वाले ऑब्जेक्ट की होगी। यहां इसे "सोमवार" मिलता है और इसलिए हैम्पप कार्यान्वयन इसे फिर से जोड़ने की अनुमति नहीं देता क्योंकि वहां पहले से ही एक ही हैशोड वाला एक ऑब्जेक्ट और एक ही कार्यान्वयन कार्यान्वयन है

जब आप हैशकोड विधि पर टिप्पणी करते हैं, तो JVM बस तीनों ऑब्जेक्ट के लिए अलग हैशोड देता है और इसलिए यह कभी भी बराबर विधि का उपयोग करके ऑब्जेक्ट ऑब्जेक्ट के बारे में परेशान नहीं करता। और हथेप कार्यान्वयन द्वारा जोड़ा गया मानचित्र में तीन अलग-अलग ऑब्जेक्ट होंगे।