मैं प्रदान किए गए उत्तरों को थोड़ा विस्तार दे रहा हूं (क्योंकि अब तक वे अपने "अपने" / कृत्रिम शब्दावली पर ध्यान केंद्रित करते हैं, विशेष रूप से प्रोग्रामिंग भाषाओं को बनाने के दृश्य के पीछे की बड़ी तस्वीर का ध्यान रखने के बजाय किसी विशेष भाषा की प्रोग्रामिंग पर ध्यान केंद्रित करते हैं, अर्थात जब चीजें होती हैं टाइप-सेफ्टी बनाम मेमोरी लिस्ट में फर्क पड़ता है):
int बूलियन नहीं है
विचार करें
boolean bar = true;
System.out.printf("Bar is %b\n", bar);
System.out.printf("Bar is %d\n", (bar)?1:0);
int baz = 1;
System.out.printf("Baz is %d\n", baz);
System.out.printf("Baz is %b\n", baz);
आउटपुट के साथ
Bar is true
Bar is 1
Baz is 1
Baz is true
तीसरी पंक्ति में जावा कोड (bar)?1:0यह दर्शाता है कि बार ( बूलियन ) को कथित तौर पर एक इंट में नहीं बदला जा सकता है । मैं इसे जेवीएम के पीछे कार्यान्वयन के विवरणों को स्पष्ट नहीं करने के लिए ला रहा हूं, लेकिन यह इंगित करने के लिए कि निम्न स्तर के विचारों (स्मृति आकार के रूप में) के लिए किसी को प्रकार की सुरक्षा से अधिक मूल्यों को पसंद करना होगा। खासकर अगर उस प्रकार की सुरक्षा वास्तव में / पूरी तरह से बूलियन प्रकारों के रूप में उपयोग नहीं की जाती है, जहां चेक के रूप में किया जाता है
यदि मान {{0,1} में है, तो बुलियन प्रकार के लिए डाले, अन्यथा एक अपवाद फेंक दें।
सभी को केवल यह बताने के लिए कि {0,1} <{-2 ^ 31, .., 2 ^ 31 -1}। एक overkill की तरह लगता है, है ना? टाइप सुरक्षा वास्तव में उपयोगकर्ता परिभाषित प्रकारों में महत्वपूर्ण है, आदिमों की अंतर्निहित कास्टिंग में नहीं (हालांकि अंतिम पहले में शामिल हैं)।
बाइट प्रकार या बिट्स नहीं हैं
ध्यान दें कि {0,1} की सीमा से आपका चर अभी भी कम से कम एक बाइट या शब्द (रजिस्टर के आकार पर निर्भर करता है) पर कब्जा कर लेगा, जब तक कि विशेष रूप से ध्यान नहीं दिया जाता (उदाहरण के लिए स्मृति में अच्छी तरह से पैक - 8 "बूलियन" 1 बाइट में बिट्स - आगे और पीछे)।
अतिरिक्त मूल्य पैकिंग (जैसे बिट शिफ्ट या अंकगणित का उपयोग करके) पर टाइप सेफ्टी (जैसे किसी विशेष प्रकार के बॉक्स में वैल्यू लगाना / लपेटना) को प्राथमिकता देकर, कोई भी अधिक मेमोरी हासिल करने के लिए प्रभावी रूप से कम कोड लिखना चुनता है। (दूसरी ओर कोई हमेशा एक कस्टम उपयोगकर्ता प्रकार को परिभाषित कर सकता है जो बूलियन की तुलना में सभी रूपांतरण की सुविधा देगा)।
कीवर्ड बनाम प्रकार
अंत में, आपका प्रश्न कीवर्ड बनाम प्रकार की तुलना करने के बारे में है । मेरा मानना है कि यह महत्वपूर्ण है समझाने के लिए क्यों या कैसे वास्तव में आप का उपयोग / पसंद करते हैं कीवर्ड जोड़ें ( "चिह्नित" के रूप में द्वारा प्रदर्शन मिल जाएगा आदिम प्रकार से अधिक) (सामान्य समग्र उपयोगकर्ता के definable एक और खोजशब्द का उपयोग कर वर्गों वर्ग दूसरे शब्दों में) या
boolean foo = true;
बनाम
Boolean foo = true;
पहला "चीज़" (प्रकार) बढ़ाया नहीं जा सकता है (उपवर्ग) और बिना कारण के नहीं। आदिम और रैपिंग कक्षाओं के प्रभावी रूप से जावा शब्दावली को केवल इनलाइन मान में अनुवाद किया जा सकता है (एक LITERAL या एक स्थिरांक जो संकलक से सीधे जुड़ जाता है, जब भी प्रतिस्थापन का अनुमान लगाना संभव हो या नहीं - फिर भी मूल्य को लपेटने में कमबैक)।
अनुकूलन तुच्छता के कारण प्राप्त होता है:
"कम रनिंग कास्टिंग ऑपरेशन => अधिक गति।"
इसीलिए जब वास्तविक प्रकार का निष्कर्ष निकाला जाता है, तो यह (अभी भी) सभी प्रकार की सूचनाओं के साथ रैपिंग क्लास के तत्कालकरण में समाप्त हो सकता है यदि आवश्यक हो (या ऐसे में परिवर्तित / कास्टिंग)।
तो, के बीच का अंतर बूलियन और बूलियन में वास्तव में संकलन और रनटाइम (थोड़ा दूर जा रहा है, लेकिन लगभग रूप में instanceof बनाम getClass () )।
अंत में, ऑटोबॉक्सिंग आदिमों की तुलना में धीमा है
इस तथ्य पर ध्यान दें कि जावा ऑटोबॉक्सिंग कर सकता है बस एक "सिंटैक्टिक शुगर" है। यह कुछ भी गति नहीं देता है, बस आपको कम कोड लिखने की अनुमति देता है। बस। टाइप सूचना कंटेनर में कास्टिंग और रैपिंग अभी भी किया जाता है। प्रदर्शन कारणों से अंकगणित का चयन करें जो हमेशा प्रकार की सुरक्षा को लागू करने के लिए प्रकार की जानकारी के साथ वर्ग उदाहरण बनाने के अतिरिक्त हाउसकीपिंग को छोड़ देगा। प्रकार की सुरक्षा का अभाव वह मूल्य है जो आप प्रदर्शन हासिल करने के लिए अदा करते हैं। बूलियन-मूल्यवान अभिव्यक्तियों के साथ कोड के लिए सुरक्षा (जब आप कम लिखते हैं और इसलिए अंतर्निहित कोड) महत्वपूर्ण होते हैं, उदाहरण के लिए if-if-अन्यथा प्रवाह नियंत्रण।