दिलचस्प पोस्ट
CudaMalloc () सूचक को पॉइंटर का उपयोग क्यों करता है? ब्राउज़र द्वारा निर्धारित अपलोड फ़ाइल का माइम प्रकार कैसा है? PHP serialize () और unserialize () का उपयोग कैसे करें एंड्रॉइड मीडियाप्लेयर त्रुटि (1, -2147483648) नए टैब में यूआरएल खोलें या जब भी संभव हो तो मौजूदा एक का पुन: उपयोग करें सी प्रीप्रोसेसर से एक संदेश को प्रिंट करने का एक पोर्टेबल तरीका है? मॉड्यूल घोषणा के लिए कोणीय जे एस सर्वोत्तम अभ्यास? ऐप्पल पीएनएस (अधिसूचना सेवाएं धक्का) नमूना कोड अभिगम नियंत्रण-अनुमति-उत्पत्ति द्वारा मूल नल की अनुमति नहीं है asp.net-mvc: रेजर '@' प्रतीक जेएस फ़ाइल में awk या sed के साथ एक कॉलम हटाएं एक इंटरफ़ेस को लागू करने वाले सभी प्रकार प्राप्त करना Android में ScrollView का उपयोग कैसे करें? सी ++ में एक बेस के अतिभारित फ़ंक्शन को ओवरराइड करना क्या सामग्री_स्क्रिप्ट "क्रोम-एक्सटेंशन: // * / *" से मेल खाता है?

लोग अभी भी जावा में आदिम प्रकार का उपयोग क्यों करते हैं?

जावा 5 के बाद से, हमने आदिम प्रकारों के मुक्केबाजी / अनबॉक्स्सिंग का सामना किया है ताकि java.lang.Integer लिए लिपटे हो। java.lang.Integer , और इतने और और भी आगे।

मैं हाल ही में बहुत सी नई जावा प्रोजेक्ट देख रहा हूं (जो निश्चित रूप से कम से कम 5 संस्करण के एक जेआरई की आवश्यकता होती है, यदि नहीं 6) जो java.lang.Integer का उपयोग कर रहे java.lang.Integer , हालांकि यह बाद के उपयोग के लिए अधिक सुविधाजनक है, क्योंकि यह है long मूल्य एट अल को परिवर्तित करने के लिए कुछ सहायक विधियों

कुछ अभी भी जावा में आदिम प्रकारों का उपयोग क्यों करते हैं? क्या कोई ठोस लाभ है?

वेब के समाधान से एकत्रित समाधान "लोग अभी भी जावा में आदिम प्रकार का उपयोग क्यों करते हैं?"

यहोशू ब्लॉच के प्रभावी जावा में , आइटम 5: "अनावश्यक वस्तुओं को बनाने से बचें", वह निम्नलिखित कोड उदाहरण पोस्ट करता है:

 public static void main(String[] args) { Long sum = 0L; // uses Long, not long for (long i = 0; i <= Integer.MAX_VALUE; i++) { sum += i; } System.out.println(sum); } 

और इसे चलाने के लिए 43 सेकंड लगते हैं। आदिम में लांग लेते हुए यह 6.8 सेकंड तक लाता है … अगर यह कोई संकेत है कि हम प्राथमिकताओं का उपयोग क्यों करते हैं

मूल मूल्य समानता की कमी भी एक चिंता है ( .equals() == की तुलना में काफी .equals() है)

बिज़िकलोप के लिए:

 class Biziclop { public static void main(String[] args) { System.out.println(new Integer(5) == new Integer(5)); System.out.println(new Integer(500) == new Integer(500)); System.out.println(Integer.valueOf(5) == Integer.valueOf(5)); System.out.println(Integer.valueOf(500) == Integer.valueOf(500)); } } 

का परिणाम:

 false false true false 

संपादित करें क्यों (3) true वापस आते true और (4) वापस लौटते हैं?

क्योंकि वे दो भिन्न वस्तुओं हैं शून्य से निकटतम 256 पूर्णांक [-128; 127] को जेवीएम द्वारा कैश्ड किया गया है, इसलिए वे उसी ऑब्जेक्ट को उन लोगों के लिए वापस लौटाते हैं। उस सीमा से परे, हालांकि, वे कैश्ड नहीं किए जाते हैं, इसलिए एक नया ऑब्जेक्ट बनाया जाता है। चीजों को और अधिक जटिल बनाने के लिए, जेएलएस मांग करता है कि कम से कम 256 फ्लाईवेइट कैश किए जाएंगे। यदि वे चाहें तो जेवीएम कार्यान्वयनकर्ता अधिक जोड़ सकते हैं, जिसका मतलब है कि यह एक ऐसे सिस्टम पर चलाया जा सकता है जहां निकटतम 1024 को कैश्ड किया गया है और ये सभी सच्चे वापस आते हैं … #

Autounboxing मुश्किल एनपीई हाजिर करने के लिए नेतृत्व कर सकते हैं

 Integer in = null; ... ... int i = in; // NPE at runtime 

अधिकतर स्थितियों में ऊपर की तुलना में कम असाइनमेंट कम स्पष्ट है

आदिम प्रकार:

 int x = 1000; int y = 1000; 

अब मूल्यांकन करें:

 x == y 

यह true शायद ही आश्चर्य की बात। अब बॉक्सिंग प्रकारों का प्रयास करें:

 Integer x = 1000; Integer y = 1000; 

अब मूल्यांकन करें:

 x == y 

यह false शायद। रनटाइम पर निर्भर करता है क्या यह कारण पर्याप्त है?

बॉक्स वाले प्रकार के खराब प्रदर्शन और अधिक स्मृति की आवश्यकता होती है।

प्रदर्शन और स्मृति मुद्दों के अलावा, मैं एक और मुद्दे के साथ आना चाहूंगा: List इंटरफ़ेस बिना किसी int टूटेगा।
समस्या ओवरलोडेड remove() विधि है ( remove(int) बनाम remove(Object) )। remove(Integer) हमेशा बाद के कॉल करने के लिए हल होगा, ताकि आप सूचकांक के द्वारा एक तत्व को नहीं निकाल सके।

दूसरी तरफ, एक अंतर को जोड़ने और हटाने का प्रयास करते समय एक गड़बड़ी होती है:

 final int i = 42; final List<Integer> list = new ArrayList<Integer>(); list.add(i); // add(Object) list.remove(i); // remove(int) - Ouch! 

क्या आप वाकई कल्पना कर सकते हैं?

  for (int i=0; i<10000; i++) { do something } 

इसके बजाय java.lang.Integer के साथ लूप? एक java.lang.Integer अपरिवर्तनीय है, इसलिए लूप के प्रत्येक वेतन वृद्धि से ही एक जेवीएम निर्देश के साथ स्टैक पर इंट बढ़ने के बजाय, ढेर पर एक नया जावा ऑब्जेक्ट बन जाएगा। प्रदर्शन शैतानी हो जाएगा

मैं सच में असहमत होता कि यह int से java.lang.Integer का उपयोग करने के लिए सुविधाजनक है। इसके विपरीत। ऑटोबोक्सिंग का मतलब है कि आप इंट का उपयोग कर सकते हैं जहां आप अन्यथा पूर्णांक का उपयोग करने के लिए मजबूर हो जाएंगे, और जावा कंपाइलर आपके लिए नए पूर्णांक ऑब्जेक्ट बनाने के लिए कोड डालने का ख्याल रखता है। ऑटोबॉक्सिंग, आप एक इंट का उपयोग करने की इजाजत देने के बारे में है, जहां एक पूर्णांक की अपेक्षा होती है, कम्पाइलर के साथ संबंधित वस्तु निर्माण को सम्मिलित करना। यह किसी भी तरह से पहली जगह में अंतर की आवश्यकता को कम या कम कर देता है। ऑटोबॉक्सिंग के साथ आप दोनों दुनिया का सर्वश्रेष्ठ प्राप्त करते हैं। जब आप एक ढेर पर आधारित जावा ऑब्जेक्ट की आवश्यकता होती है, तो आपको अपने लिए बनाया गया एक पूर्णांक मिलता है, और जब आप सिर्फ अंकगणित और स्थानीय गणना कर रहे हैं, तो आप एक इंट की गति और दक्षता प्राप्त करते हैं।

आदिम प्रकार बहुत तेज होते हैं:

 int i; i++; 

पूर्णांक (सभी नंबर और स्ट्रिंग) एक अपरिवर्तनीय प्रकार है: एक बार बनाया जाने वाला इसे परिवर्तित नहीं किया जा सकता। यदि i पूर्णांक था, तो i++ तुलना में एक नया पूर्णांक वस्तु बन जाएगी- स्मृति और प्रोसेसर के संदर्भ में अधिक महंगा।

सबसे पहले, आदत अगर आपने जावा में आठ साल के लिए कोडित किया है, तो आप जड़ता की काफी मात्रा जमा कर सकते हैं। ऐसा करने का कोई सम्मोहक कारण क्यों नहीं है? यह ऐसा नहीं है जैसे बॉक्सिंग पुरालेखों का उपयोग किसी भी अतिरिक्त लाभ के साथ आता है।

अन्य कारण यह है कि null मान्य विकल्प नहीं है। Integer रूप में दो नंबरों की संख्या या एक लूप वैरिएबल घोषित करने के लिए यह बेकार और भ्रामक होगा।

इसके प्रदर्शन का पहलू भी है, जबकि कई मामलों में प्रदर्शन अंतर महत्वपूर्ण नहीं है (यद्यपि यह बहुत खराब है), कोई भी कोड लिखना पसंद नहीं करता जो कि पहले से ही तेज़ तरीके से लिखा जा सकता है अभ्यस्त।

वैसे, स्मॉलटाक में केवल ऑब्जेक्ट्स (कोई प्राइमेटिव्स) नहीं हैं, और फिर भी उन्होंने अपने छोटे पूर्णांक को अनुकूलित किया था (सभी 32 बिट्स का इस्तेमाल नहीं करते, केवल 27 या ऐसे) किसी भी हेप स्पेस को आवंटित नहीं करने के लिए, बल्कि एक विशेष बिट पैटर्न का उपयोग करें। इसके अलावा अन्य सामान्य वस्तुओं (सच्चे, झूठे, शून्य) यहां विशेष बिट पैटर्न थे

इसलिए, कम से कम 64-बिट जेवीएम (64 बिट पॉइंटर नेमस्पेस के साथ) पूर्णांक, कैरेक्टर, बाइट, शॉर्ट, बूलियन, फ्लोट (और लम्बी लांग) के किसी भी ऑब्जेक्ट नहीं होने के बावजूद संभव है (इन निर्मित से अलग स्पष्ट new ...() ) द्वारा, केवल विशेष बिट पैटर्न, जो सामान्य ऑपरेटर द्वारा कुशलतापूर्वक कुशलता से उपयोग किया जा सकता है

मुझे विश्वास नहीं हो सकता है कि किसी ने भी उल्लेख नहीं किया है जो मुझे लगता है कि सबसे महत्वपूर्ण कारण है: "इंट" ऐसा है, "इंटीजर" से टाइप करना इतना आसान है मुझे लगता है कि लोग संक्षिप्त वाक्यविन्यास के महत्व को कम महत्व देते हैं प्रदर्शन वास्तव में उनसे बचने का एक कारण नहीं है क्योंकि ज्यादातर समय संख्या का प्रयोग करते समय लूप अनुक्रमित होते हैं, और इन लागतों की तुलना किसी गैर-तुच्छ लूप में (चाहे आप इंट या पूर्णांक का उपयोग कर रहे हैं) में बढ़ोतरी कर रहे हैं।

दूसरा कारण यह था कि आप एनपीई प्राप्त कर सकते हैं, लेकिन बॉक्सिंग प्रकार से बचने के लिए बेहद आसान है (और जब तक आप हमेशा इन्हें गैर-रिक्त मानों के लिए प्रारंभ नहीं किया जाता है, तब तक से बचने की गारंटी होती है)।

दूसरा कारण यह था कि (नया लांग (1000)) == (नया लांग (1000)) झूठा है, लेकिन ये सिर्फ यह कहने का एक और तरीका है कि ".अबल" में बॉक्सिंग प्रकारों के लिए कोई वाक्यविन्यास नहीं है (ऑपरेटर <,> , =, आदि), तो हम "सरल वाक्यविन्यास" कारण से वापस आ जाते हैं।

मुझे लगता है कि स्टीव यिग्ज का गैर-आदिम पाश उदाहरण मेरी बात को बहुत अच्छी तरह दिखाता है: http://sites.google.com/site/steveyegge2/language-trickery-and-ejb

इस बारे में सोचें: आप कितनी बार भाषाओं में फ़ंक्शन के प्रकार का प्रयोग करते हैं जिनमें उनके लिए अच्छे सिंटैक्स (जैसे कि किसी भी कार्यात्मक भाषा, अजगर, रूबी और यहां तक ​​कि सी) जावा के मुकाबले आपको ऐसे इंटरफेस का उपयोग करना है जैसे कि रननाबल और कॉल करने योग्य और अनाम वर्ग

अन्य लोगों ने क्या कहा है इसके अलावा, आदिम स्थानीय चर को ढेर से आवंटित नहीं किया गया, बल्कि इसके बजाय स्टैक पर। लेकिन वस्तुओं को ढेर से आवंटित किया जाता है और इस प्रकार कचरा एकत्र किया जाना चाहिए।

कुछ कारणों से पुराणों से छुटकारा पाने के लिए नहीं:

  • पिछला संगतता

यदि यह समाप्त हो गया है, तो किसी भी पुराने कार्यक्रम भी नहीं चलेंगे।

  • जेवीएम फिर से लिखना

इस नई चीज का समर्थन करने के लिए पूरे जेवीएम को फिर से लिखना होगा।

  • बड़ा स्मृति पदचिह्न

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

  • शून्य सूचक समस्याएं

int i घोषित करने के बाद int i सामान बना रहा i जिसके परिणामस्वरूप i कोई समस्या नहीं मिलनी चाहिए, लेकिन Integer i घोषणा करना और फिर ऐसा करना एक एनपीई का परिणाम होगा।

  • समानता के मुद्दे

इस कोड पर विचार करें:

 Integer i1 = 5; Integer i2 = 5; i1 == i2; // Currently would be false. 

गलत होगा ऑपरेटर को अतिभारित करना होगा, और इससे सामान की एक बड़ी पुनर्लेखन हो जाएगा।

  • धीरे

ऑब्जेक्ट रैपरर्स उनके आदिम समकक्षों की तुलना में काफी धीमी हैं।

ऑब्जेक्ट आदिम प्रकारों की तुलना में अधिक भारी है, इसलिए प्राचीन वर्ग आवरण कक्षाओं के उदाहरणों से अधिक कुशल होते हैं।

आदिम प्रकार बहुत सरल हैं: उदाहरण के लिए एक इंट 32 बिट्स है और मेमोरी में ठीक 32 बिट्स को लेता है, और इसे सीधे सीधा किया जा सकता है एक पूर्णांक वस्तु एक पूर्ण वस्तु है, जो (किसी भी ऑब्जेक्ट की तरह) को ढेर पर जमा करना है, और इसे केवल संदर्भ (सूचक) के माध्यम से पहुंचा जा सकता है यह सबसे अधिक संभावना स्मृति की 32 बिट (4 बाइट्स) से भी ज्यादा लेता है।

उस ने कहा, यह तथ्य कि जावा में आदिम और गैर-आदिम प्रकारों के बीच अंतर है, यह भी जावा प्रोग्रामिंग भाषा की उम्र का संकेत है। नई प्रोग्रामिंग भाषाओं में यह अंतर नहीं है; ऐसी भाषा का संकलक काफी चतुर है, यदि आप सरल मूल्यों या अधिक जटिल वस्तुओं का उपयोग कर रहे हैं

उदाहरण के लिए, स्कला में कोई आदिम प्रकार नहीं हैं; पूर्णांक के लिए एक वर्ग इंट है, और एक इंट एक वास्तविक वस्तु है (जो आप आदि के तरीकों पर) कर सकते हैं। जब कंपाइलर आपके कोड को संकलित करता है, तो यह दृश्यों के पीछे आदिम इनट का उपयोग करता है, इसलिए एक Int का उपयोग करना जावा में एक आदिम int का उपयोग करने के समान ही कुशल है।

यह पता करने में मुश्किल है कि कवर के तहत किस तरह के अनुकूलन चल रहे हैं।

स्थानीय उपयोग के लिए, जब संकलक को शून्य मान की संभावना को छोड़कर ऑप्टिमाइज़ेशन करने के लिए पर्याप्त जानकारी है, तो मुझे उम्मीद है कि प्रदर्शन समान या समान होगा

बहरहाल, पुरातनों के सरणियां बॉक्सिंग प्राइमेटिव के संकलन से बहुत अलग हैं । यह समझ में आता है कि संग्रह के भीतर बहुत कुछ अनुकूलन संभव है।

इसके अलावा, Integer मुकाबले int की तुलना में बहुत अधिक तार्किक ऊपरी भाग है : अब आपको इस बारे में चिंता करने की ज़रूरत है कि क्या int a = b + c; अपवाद फेंकता है

मैं प्राइमिटिवों का उपयोग जितना संभव हो उतना होगा और कारखाने के तरीकों और ऑटोबॉक्ज़िंग पर भरोसा करने के लिए मुझे अधिक सिमेंटिक शक्तिशाली बॉक्सिंग प्रकार देने होंगे जब वे आवश्यक हों

आदिम प्रकारों के कई फायदे हैं: – लिखने के लिए सरल कोड – प्रदर्शन बेहतर है क्योंकि आप चर के लिए किसी ऑब्जेक्ट को इन्स्तांत नहीं कर रहे हैं – चूंकि वे किसी ऑब्जेक्ट के संदर्भ का प्रतिनिधित्व नहीं करते हैं, इसलिए नाल की जांच करने की कोई आवश्यकता नहीं है – आदिम प्रकारों का उपयोग करें जब तक कि आप मुक्केबाजी सुविधाओं का लाभ लेने की आवश्यकता है

 int loops = 100000000; long start = System.currentTimeMillis(); for (Long l = new Long(0); l<loops;l++) { //System.out.println("Long: "+l); } System.out.println("Milliseconds taken to loop '"+loops+"' times around Long: "+ (System.currentTimeMillis()- start)); start = System.currentTimeMillis(); for (long l = 0; l<loops;l++) { //System.out.println("long: "+l); } System.out.println("Milliseconds taken to loop '"+loops+"' times around long: "+ (System.currentTimeMillis()- start)); 

मिलीसेकेंड को लंबे समय तक 468 के आसपास '100000000' लूप पर ले जाया गया

मिलीसेकेंड को लंबे समय के दौरान '10000000000' पाश के लिए लिया गया: 31

एक तरफ ध्यान दें, मैं ऐसा कुछ नहीं देखूँगा जैसे कि यह जावा में रास्ता है।

 Integer loop1 = new Integer(0); for (loop1.lessThan(1000)) { ... } 

जहां लूप के लिए स्वचालित रूप से लूप 1 को 1000 से 1000 या बढ़ाता है

 Integer loop1 = new Integer(1000); for (loop1.greaterThan(0)) { ... } 

जहां लूप के लिए स्वचालित रूप से लूप 1 1000 से 0 कम हो जाती है

मैं पिछली उत्तरों से सहमत हूं, पुरातन आवरण वस्तुओं का उपयोग करना महंगा हो सकता है। लेकिन, यदि आपके आवेदन में प्रदर्शन महत्वपूर्ण नहीं है, तो वस्तुओं का उपयोग करते समय आप अतिप्रवाह से बचते हैं। उदाहरण के लिए:

 long bigNumber = Integer.MAX_VALUE + 2; 

बड़ी संख्या का मूल्य bigNumber है, और आप 2147483649 होने की उम्मीद करेंगे। यह उस कोड में एक बग है जो इसे करके तय किया जाएगा:

 long bigNumber = Integer.MAX_VALUE + 2l; // note that '2' is a long now. 

और bigNumber संख्या 2147483649 होगी। इन प्रकार की कीड़े कभी-कभी याद करना आसान होती हैं और अज्ञात व्यवहार या कमजोरियों ( सीडब्ल्यूई -190 देखें) हो सकते हैं।

यदि आप आवरण वस्तु का उपयोग करते हैं, तो समकक्ष कोड संकलन नहीं करेगा।

 Long bigNumber = Integer.MAX_VALUE + 2; // Not compiling 

इसलिए प्राथमिकताएं आवरण वस्तुओं का उपयोग करके इन प्रकार के मुद्दों को रोकना आसान है

आपका प्रश्न इतना पहले ही उत्तर दिया गया है, कि मैं इससे पहले थोड़ी थोड़ी अधिक जानकारी जोड़ने के लिए उत्तर देता हूं

1) आपको गणितीय संचालन के लिए प्राथमिकताओं की जरूरत है 2) प्राथमिकताएं कम स्मृति लेती हैं जैसा कि ऊपर दिए गए उत्तर और बेहतर प्रदर्शन

आपको पूछना चाहिए कि क्लास / ऑब्जेक्ट प्रकार की आवश्यकता क्यों है

ऑब्जेक्ट प्रकार होने का कारण जब हम संग्रह से निपटते हैं, तो हमारी ज़िंदगी को आसान बनाते हैं। प्राथमिकता सूची / मानचित्र पर सीधे नहीं जोड़ा जा सकता है बल्कि आपको आवरण वर्ग लिखने की ज़रूरत है। रेडीमेड इंटीगर प्रकार की क्लासेस आपकी मदद करता है प्लस इसके पास कई उपयोगिता विधियां हैं जैसे कि पूर्णांक पारेसईआईन्ट (str)

क्योंकि जवा आदिम प्रकारों में सभी गणितीय ऑपरेशन करता है इस उदाहरण पर विचार करें:

 public static int sumEven(List<Integer> li) { int sum = 0; for (Integer i: li) if (i % 2 == 0) sum += i; return sum; } 

यहां, पूर्णांक (संदर्भ) प्रकार पर रिमाइंडर और अनारी प्लस संचालन लागू नहीं किया जा सकता, संकलक अनबॉक्सिंग करता है और ऑपरेशन करता है।

इसलिए, सुनिश्चित करें कि जावा प्रोग्राम में कितने ऑटोबॉक्सिंग और अनबॉक्सिंग ऑपरेशन होते हैं। चूंकि, यह ऑपरेशन करने के लिए समय लगता है।

सामान्यतया, प्रकार के तर्क और आरम्भिक प्रकार का तर्क रखने के लिए बेहतर है