दिलचस्प पोस्ट
एसएफ़टीपी लाइब्रेरीज़ .नेट के लिए मैं जावा में वर्तमान तारीख को एक महीने कैसे जोड़ूं? MVC प्रगति बार थ्रेडिंग नाम से डेटा फ्रेम कॉलम ड्रॉप करें IE के लिए सीएसएस 'पॉइंटर-इवेंट' प्रॉपर्टी विकल्प एपीआई कुंजी को उजागर करें PHP में – (डबल बृहदान्त्र) और -> (तीर) के बीच अंतर क्या है? क्या इनटस्टस्ट्रीम से टाइमआउट के साथ पढ़ना संभव है? जटिल प्रकारों के साथ स्पार्क एसक्यूएल डाटाफ़्रेम पूछताछ करना सी # कन्स्ट्रक्टर अनुमानक प्रकार क्यों नहीं? रन और फ़ंक्शन संरचना कैसे MongoDB को विंडोज सर्विस के रूप में चलाने के लिए? क्या एंड्रॉइड व्यू के ऊपर और नीचे सीमा को जोड़ने का एक आसान तरीका है? लूप सिंटैक्स के लिए जावा: "for (T obj: objects)" जावा 8 में डिफ़ॉल्ट या डिफेंडर विधियों का उद्देश्य

जावा enum सदस्यों की तुलना: == या बराबर ()?

मुझे पता है कि जावा एंमोएं निजी कन्स्ट्रक्टरों और सार्वजनिक स्थैतिक सदस्यों के समूह के साथ कक्षाओं में संकलित हैं। जब किसी दिए गए .equals() दो सदस्यों की तुलना करते हैं, तो मैंने हमेशा इसका उपयोग किया है

 public useEnums(SomeEnum a) { if(a.equals(SomeEnum.SOME_ENUM_VALUE)) { ... } ... } 

हालांकि, मैं बस कुछ कोड में आया था जो बराबर ऑपरेटर == बजाय .equals ():

 public useEnums2(SomeEnum a) { if(a == SomeEnum.SOME_ENUM_VALUE) { ... } ... } 

कौन सा ऑपरेटर मुझे उपयोग करना चाहिए?

वेब के समाधान से एकत्रित समाधान "जावा enum सदस्यों की तुलना: == या बराबर ()?"

दोनों तकनीकी रूप से सही हैं यदि आप सोर्स कोड को .equals() के लिए .equals() , तो यह केवल == के लिए .equals()

मैं == उपयोग करता हूं, हालांकि, क्योंकि यह रिक्त सुरक्षित होगा।

कर सकते हैं == enum पर इस्तेमाल किया जा सकता है?

हां: एनाम में तंग उदाहरण नियंत्रण होते हैं जो आपको उदाहरणों की तुलना करने के लिए == का उपयोग करने की अनुमति देता है। भाषा विनिर्देश द्वारा प्रदान की जाने वाली गारंटी यहां दी गई है:

जेएलएस 8.9 एनरम्स

एक एन्यूम प्रकार में इसके एनएम स्थिरांक द्वारा परिभाषित किसी भी अन्य उदाहरण नहीं हैं।

यह एक एम्पल प्रकार को स्पष्ट रूप से इन्स्तांत करने का प्रयास करने के लिए एक संकलन-समय त्रुटि है। Enum में final clone विधि यह सुनिश्चित करता है कि enum स्थिरांक कभी क्लोन नहीं किए जा सकते हैं, और क्रमिकरण तंत्र द्वारा विशेष उपचार सुनिश्चित करता है कि दोहरे उदाहरणों को deserialization के परिणामस्वरूप कभी नहीं बनाया गया है। एंनाम प्रकारों के चिंतनशील तात्पर्य निषिद्ध है। एक साथ, इन चार चीजों से यह सुनिश्चित होता है कि enum प्रकार के कोई भी उदाहरण enum स्थिरांक द्वारा परिभाषित नहीं किए गए हैं।

चूंकि प्रत्येक enum निरंतर का केवल एक उदाहरण है, दो ऑब्जेक्ट संदर्भों की तुलना करते समय यह equals विधि के स्थान पर == ऑपरेटर का उपयोग करने के लिए अनुमत है , यदि यह ज्ञात है कि उनमें से कम से कम एक enum स्थिरांक को दर्शाता है । ( Enum में equals विधि एक final विधि है जो केवल super.equals को अपनी तर्क पर super.equals करती है और परिणाम देता है, इस तरह एक पहचान तुलना करता है।)

यह गारंटी काफी मजबूत है कि जोश ब्लाच सिफारिश करता है कि यदि आप सिंगलटन पैटर्न का उपयोग करने पर जोर देते हैं, तो इसे लागू करने का सबसे अच्छा तरीका एक एकल तत्व enum का उपयोग करना है (देखें: प्रभावी जावा 2 संस्करण, आइटम 3: सिंगलटन संपत्ति को लागू करना एक निजी कंस्ट्रक्टर या एक एन्यूम प्रकार ; एकल सूत्र में भी थ्रेड सुरक्षा )


== और equals बीच अंतर क्या हैं?

एक अनुस्मारक के रूप में, यह कहा जाना चाहिए कि आम तौर पर, == equals एक व्यवहार्य विकल्प नहीं equals । जब यह है, हालांकि (जैसे मान के साथ), इस पर विचार करने के लिए दो महत्वपूर्ण अंतर हैं:

== NullPointerException फेंकता नहीं

 enum Color { BLACK, WHITE }; Color nothing = null; if (nothing == Color.BLACK); // runs fine if (nothing.equals(Color.BLACK)); // throws NullPointerException 

== संकलन समय पर संगतता जांच प्रकार के अधीन है

 enum Color { BLACK, WHITE }; enum Chiral { LEFT, RIGHT }; if (Color.BLACK.equals(Chiral.LEFT)); // compiles fine if (Color.BLACK == Chiral.LEFT); // DOESN'T COMPILE!!! Incompatible types! 

लागू होने पर क्या == उपयोग किया जाना चाहिए?

ब्लिक ने विशेष रूप से उल्लेख किया है कि अपरिवर्तनीय वर्ग जिन्हें उनके उदाहरणों पर उचित नियंत्रण है, वे अपने ग्राहकों को गारंटी दे सकते हैं कि == उपयोग करने योग्य है enum विशेष रूप से उदाहरण देने के लिए वर्णित है

मद 1: कन्स्ट्रक्टरों के बजाय स्थैतिक कारखाने के तरीकों पर विचार करें

[…] यह एक अपरिवर्तनीय वर्ग को गारंटी देने के लिए अनुमति देता है कि कोई दो बराबर उदाहरण मौजूद नहीं हैं: a.equals(b) यदि और केवल अगर a==b यदि कोई वर्ग इस गारंटी को बनाता है, तो उसके ग्राहक equals(Object) विधि के बजाय == ऑपरेटर का उपयोग कर सकते हैं, जिसके परिणामस्वरूप बेहतर प्रदर्शन हो सकता है। Enum प्रकार इस गारंटी प्रदान करते हैं।

संक्षेप में, enum पर == का उपयोग करने के लिए तर्क हैं:

  • यह काम करता हैं।
  • यह तेज है।
  • रन-टाइम में यह सुरक्षित है
  • संकलन-समय पर यह सुरक्षित है

दो enum मानों की तुलना करने के लिए == का इस्तेमाल करना कार्य करता है क्योंकि प्रत्येक enum स्थिरांक के लिए केवल एक वस्तु है

एक साइड नोट पर, वास्तव में शून्य सुरक्षा कोड लिखने के लिए == का इस्तेमाल करने की कोई ज़रूरत नहीं है यदि आप अपने equals() इस प्रकार लिखते हैं:

 public useEnums(SomeEnum a) { if(SomeEnum.SOME_ENUM_VALUE.equals(a)) { ... } ... } 

यह एक बेहतरीन अभ्यास है जिसे बाएं से तुलना करें तुलना करें जिसे आप निश्चित रूप से पालन करना चाहिए।

जैसा कि दूसरों ने कहा है, ज्यादातर मामलों में दोनों == और .equals() काम करते हैं। संकलन समय निश्चित है कि आप पूरी तरह से विभिन्न प्रकार के ऑब्जेक्ट्स की तुलना नहीं कर रहे हैं जो अन्य ने इंगित किया है जो वैध और फायदेमंद है, हालांकि दो अलग-अलग संकलन प्रकारों की वस्तुओं की तुलना करने के विशेष प्रकार के बग भी FindBugs (और शायद ग्रहण / IntelliJ संकलन समय निरीक्षण), तो जावा कम्पाइलर खोज यह है कि बहुत अधिक सुरक्षा नहीं जोड़ता है

तथापि:

  1. तथ्य यह है कि == मेरे मन में एनपीई कभी नहीं फेंकता है == नुकसान । किसी भी अतिरिक्त स्थिति के बिना किसी भी अतिरिक्त स्थिति को null करने के लिए कभी भी enum प्रकार की ज़रूरत नहीं होनी चाहिए, क्योंकि आप बिना किसी null व्यक्त करना चाहते हैं, सिर्फ एक अतिरिक्त उदाहरण के रूप में enum में जोड़ा जा सकता है। अगर यह अप्रत्याशित रूप से null , तो मैं इसके बजाय null से मूल्यांकन करने के लिए == तुलना में एक NPE है। इसलिए मैं सहमत हूं कि यह रन-टाइम राय में सुरक्षित है ; आदतन में शामिल होने के लिए बेहतर है कभी नहीं enum मूल्यों को @Nullable
  2. यह तर्क है कि == तेज भी फर्जी है अधिकतर मामलों में आप चर पर एक .equals() कॉल करेंगे, जिसका संकलन समय प्रकार enum वर्ग है, और उन मामलों में कंपाइलर जान सकता है कि यह वही == (क्योंकि एक enum की equals() विधि कर सकते हैं ओवरराइड न हो) और फंक्शन कॉल को दूर कर सकते हैं। मुझे यकीन नहीं है कि कंपाइलर वर्तमान में यह करता है, लेकिन यदि यह नहीं है, और जावा में एक कार्यक्षमता की समस्या पूरी तरह से निकलती है, तो मैं कम्पाइलर को ठीक करने के बजाय 100,000 जावा प्रोग्रामर को अपनी प्रोग्रामिंग शैली को बदलना चाहता हूं एक विशेष संकलक संस्करण का प्रदर्शन विशेषताओं
  3. enums ऑब्जेक्ट हैं अन्य सभी ऑब्जेक्ट प्रकारों के लिए मानक तुलना .equals() , नहीं == मुझे लगता है कि यह enums लिए एक अपवाद बनाने के लिए खतरनाक है क्योंकि आप अंततः equals() == साथ ऑब्जेक्ट्स की तुलना करना equals() बजाय तुलना कर सकते हैं, खासकर यदि आप गैर-एन्यूम वर्ग में enum करते हैं इस तरह के एक पुनर्संरचना के मामले में, यह ऊपर से बिंदु काम करता है गलत है। अपने आप को यह समझने के लिए कि == का उपयोग सही है, आपको यह जांचना होगा कि प्रश्न में मूल्य या तो एक enum या आदिम है; अगर यह एक गैर- enum वर्ग था, यह गलत होगा, लेकिन याद करना आसान होगा क्योंकि कोड अभी भी संकलित होगा। एकमात्र मामला जब .equals() का उपयोग गलत होगा यदि प्रश्न में मूल्य primitives थे; उस स्थिति में, कोड संकलित नहीं होता, इसलिए यह याद करना बहुत मुश्किल है अत :, .equals() सही के रूप में पहचानना आसान है, और भविष्य के .equals() विरुद्ध सुरक्षित है।

मैं वास्तव में सोचता हूं कि जावा भाषा को ऑब्जेक्ट पर =================================================================================================================================================================================================

संक्षेप में, मुझे अभी भी लगता है कि बहसें enum प्रकारों के लिए .equals() का उपयोग करने के पक्ष में हैं।

दो की तुलना करने के लिए यहां एक क्रूड टाइमिंग टेस्ट है:

 import java.util.Date; public class EnumCompareSpeedTest { static enum TestEnum {ONE, TWO, THREE } public static void main(String [] args) { Date before = new Date(); int c = 0; for(int y=0;y<5;++y) { for(int x=0;x<Integer.MAX_VALUE;++x) { if(TestEnum.ONE.equals(TestEnum.TWO)) {++c;} if(TestEnum.ONE == TestEnum.TWO){++c;} } } System.out.println(new Date().getTime() - before.getTime()); } } 

अगर एक समय में एक से बाहर टिप्पणी करें उपरोक्त दोट बाइट-कोड में दो तुलना निम्न हैं:

  21 getstatic EnumCompareSpeedTest$TestEnum.ONE : EnumCompareSpeedTest.TestEnum [19] 24 getstatic EnumCompareSpeedTest$TestEnum.TWO : EnumCompareSpeedTest.TestEnum [25] 27 invokevirtual EnumCompareSpeedTest$TestEnum.equals(java.lang.Object) : boolean [28] 30 ifeq 36 36 getstatic EnumCompareSpeedTest$TestEnum.ONE : EnumCompareSpeedTest.TestEnum [19] 39 getstatic EnumCompareSpeedTest$TestEnum.TWO : EnumCompareSpeedTest.TestEnum [25] 42 if_acmpne 48 

पहले (बराबर) वर्चुअल कॉल करता है और स्टैक से वापसी बूलीयन की जांच करता है। दूसरा (==) ऑब्जेक्ट पतों को सीधे स्टैक से तुलना करता है। पहले मामले में अधिक गतिविधि है।

मैं एक बार में एक बार दोनों के साथ कई बार इस परीक्षा में भाग गया "==" कभी भी थोड़ा तेज है

मैं equals बजाय == का उपयोग करना पसंद करता हूं:

अन्य कारण, पहले से ही यहां चर्चा की गई अन्य लोगों के अतिरिक्त, क्या आप इसे बग़ैर बिना बग शुरू कर सकते हैं मान लीजिए आपके पास यह ऊर्जा है जो बिल्कुल वही है, लेकिन अलग-अलग पैकेजेस (यह सामान्य नहीं है, लेकिन ऐसा हो सकता है):

पहला मान :

 package first.pckg public enum Category { JAZZ, ROCK, POP, POP_ROCK } 

दूसरा मान:

 package second.pckg public enum Category { JAZZ, ROCK, POP, POP_ROCK } 

तो मान लीजिए कि आप उपयोग करते हैं, तो item.category में पहले item.category होता है, जो कि पहले first.pckg.Category लेकिन आप इसके बजाय पहली second.pckg.Category (दूसरी. second.pckg.Category ) को आयात करते हैं, जो पहले इसे महसूस किए बिना:

 import second.pckg.Category; ... Category.JAZZ.equals(item.getCategory()) 

तो आप सभी तरह से false हो जाएंगे, क्योंकि एक अलग item.getCategory() हालांकि आप सच मानते हैं क्योंकि item.getCategory() है। और यह देखना मुश्किल हो सकता है

इसलिए, यदि आप इसके बजाय ऑपरेटर का इस्तेमाल करते हैं == तो आपके पास एक संकलन त्रुटि होगी:

ऑपरेटर == को "सेकंड.pckg.Category", "प्रथम.pckg.Category" पर लागू नहीं किया जा सकता है

 import second.pckg.Category; ... Category.JAZZ == item.getCategory() 

Enum के मामले में दोनों सही और सही हैं !!

एएनम स्थिरांक की तुलना करने के लिए == अलावा अन्य कुछ भी प्रयोग करना बकवास है यह equals साथ class वस्तुओं की तुलना की तरह equals – ऐसा मत करो!

हालांकि, सन जेडीके 6u10 में और इससे पहले एक गंदे बग (BugId 6277781 ) था जो कि ऐतिहासिक कारणों के लिए दिलचस्प हो सकता है। इस बग ने deserialized enums पर == का उचित उपयोग को रोका, हालांकि यह एक कोने के मामले का तर्क है।

एन्यूम उन कक्षाएं हैं जो प्रत्येक स्थिरांक public static final field (अपरिवर्तनीय) द्वारा घोषित प्रत्येक गणण निरंतरता के लिए एक उदाहरण (जैसे सिंगलटन) लौटाते हैं, जिससे कि == ऑपरेटर का प्रयोग समानता equals() विधि की बजाय अपनी समानता की जांच के लिए किया जा सकता है

संक्षेप में, दोनों पेशेवर और विपक्ष हैं

एक तरफ, इसका उपयोग == का उपयोग करने के लिए फायदे हैं, जैसा कि अन्य उत्तरों में वर्णित है।

दूसरी ओर, यदि आप किसी भी कारण से एक अलग दृष्टिकोण (सामान्य वर्ग के उदाहरण) के साथ enums की जगह, == उपयोग कर आप काटने (BTDT।)

आप इसका उपयोग कर सकते हैं: ==, बराबर () या स्विच () ब्लॉक को एनोम की तुलना करने के लिए, ये सभी तकनीकी रूप से सत्य हैं और आपकी ज़रूरत की पूर्ति करेंगे।

Enum के सामान्य कार्यों के बारे में अधिक जानने के लिए इस ट्यूटोरियल की जांच करें: जावा में ऐन्यूम का उपयोग कैसे करें

मैं पोलिजेन्यूब्रिकेंट का जवाब देना चाहता हूं:

मैं व्यक्तिगत रूप से बराबर पसंद करता हूं () लेकिन यह प्रकार संगतता जांच झील। जो मुझे लगता है कि एक महत्वपूर्ण सीमा है

संकलन समय पर प्रकार संगतता जांच करने के लिए, अपनी एन्यूम में एक कस्टम फ़ंक्शन का प्रयोग करें और उपयोग करें।

 public boolean isEquals(enumVariable) // compare constant from left public static boolean areEqual(enumVariable, enumVariable2) // compare two variable 

इसके साथ, आपको दोनों समाधानों का लाभ मिला: एनपीई सुरक्षा, संकलन समय पर कोड और प्रकार संगतता जांच को पढ़ने में आसान।

मैं भी enum के लिए एक UNDEFINED मान जोड़ने की सलाह देते हैं

मैं == ऑपरेटर और equals() विधि के बीच इस विशिष्ट अंतर को स्पष्ट रूप से हाइलाइट करना चाहूंगा:

equals() विधि का मतलब यह है कि ऑब्जेक्ट की सामग्री संदर्भ संदर्भों में शामिल संदर्भ (एस) को समान हैं या नहीं।

== ऑपरेटर जांचता है कि क्या संदर्भ वेरिएबल शामिल हैं (संदर्भों) को उसी ऑब्जेक्ट में देखें

आवेदन के ज़रिए यह भेदभाव प्रदान करने के लिए कार्यान्वयन वर्ग पर निर्भर है।

अन्यथा डिफ़ॉल्ट व्यवहार Object क्लास (जावा में) द्वारा प्रदान किया जाएगा, जहां http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Object.html#equals में समझाया गया है ( java.lang.Object) :

कक्षा Object लिए equals विधि Object पर सबसे भेदभाव संभव तुल्यता संबंध लागू करता है; यह है कि, किसी भी गैर-निरर्थक संदर्भ मानों के लिए x और y , यह विधि true और अगर केवल अगर x और y एक ही ऑब्जेक्ट को संदर्भित करता है ( x == y पास मान true )।