विधि अक्षम नए इंटीजर (int) कन्स्ट्रक्टर का आह्वान करता है; इसके बजाय Integer.valueOf (int) का उपयोग करें

Question

मेरा उद्देश्य मेरा एप्लिकेशन कोड अनुकूलित करना है। मेरे कोड इस तरह दिखता है:

int a = 10; 
Map<String , Integer> myMap = new TreeMap<>(); 

myMap.put("first" , new Integer(a)); //[FindBugs] Method com.abc.xyz.Test.main(String[]) invokes inefficient new Integer(int) constructor; use Integer.valueOf(int) instead 

जब मैं Netbeans में FindBugs द्वारा स्थिर विश्लेषण किया था, यह पता चलता है की तरह "विधि एक चेतावनी/बग अक्षम नई पूर्णांक (int) निर्माता invokes है कि वहाँ; Integer.valueOf का उपयोग करें (int) इसके बजाय "।

मैं नई पूर्णांक (int) बनाम Integer.valueOf (int) के बीच अंतर पता है।

एक अतिरिक्त वस्तु बनाता है और दूसरा नहीं। इसके अलावा कोई कैशिंग और अन्य कैश नहीं करता है।

तो मैं इस तरह मेरे को संशोधित किया है ...

m.put("first" , Integer.valueOf(a)); // Unnecessary boxing to Integer 

लेकिन फिर भी चेतावनी "पूर्णांक को अनावश्यक मुक्केबाजी" (संपादक द्वारा FindBugs द्वारा नहीं) देता है।

तो, मैं इसे फिर से इस तरह के रूप में बदल दिया है ....

m.put("first" , a); //No warning at all... 

जो अंत में बिल्कुल देता है कोई चेतावनी।

मेरे प्रश्न:

1.) इस link सुझाव है कि आंतरिक रूप से (संकलक द्वारा) m.put ("प्रथम", एक);m.put में परिवर्तित हो रहा है ("पहला", Integer.valueOf (ए));

(उस उदाहरण पर, एक सूची-ऐरेलिस्ट है और यहां हमारे पास मानचित्र-ट्रीमैप है ... एफवाईआई)। फिर संपादक क्यों चेतावनी देता है? और मुझे क्या करना चाहिए? अनुकूलित तरीका क्या है?

2.) यदि मानचित्र के बजाय, अगर वहाँ HashTable तो जैसे किसी भी डेटा संरचना है ???

3.) संपादक अनावश्यक मुक्केबाजी को क्यों देता है।

4.) m.put ("पहला", ए) काम करता है? क्योंकि मैं आदिम चर पास कर रहा हूं और मानचित्र के पुट() केवल ऑब्जेक्ट स्वीकार कर रहा हूं। तो ऑटो मुक्केबाजी की वजह से है?

Answer 1

1.) यह लिंक आंतरिक रूप से (कंपाइलर द्वारा) m.put ("पहला", ए); m.put में परिवर्तित हो रहा है ("पहला", Integer.valueOf (ए));

(उस उदाहरण पर, एक सूची-ऐरेलिस्ट है और यहां हमारे पास मानचित्र-ट्रीमैप है ... एफवाईआई)। तो संपादक चेतावनी क्यों देता है? और मुझे क्या करना चाहिये? अनुकूलित तरीका क्या है?

हां, संकलक जानता है कि m.put("first", a) केवल ऑब्जेक्ट स्वीकार करता है और इस प्रकार ऑटोबॉक्सिंग लागू होता है। प्रदर्शन के संदर्भ में, ऑटोबॉक्सिंग या Integer.valueOf(a) लिखने से कोई फर्क नहीं पड़ता।

दूसरी ओर, new Integer(a)Integer.valueOf(a) से वास्तव में धीमी नहीं है। अंतर यह है कि छोटे पूर्ण मूल्यों के लिए (डिफ़ॉल्ट -128 से 127) Integer.valueOf(a) कैश का उपयोग करेगा, यानी हर समय नई ऑब्जेक्ट्स नहीं बनाएंगे। अन्य सभी मूल्यों के लिए यह new Integer(a) किसी भी तरह से आमंत्रित करेगा।

उदाहरण:

Integer.valueOf(1) == Integer.valueOf(1) निकलेगा सच
Integer.valueOf(1000) == Integer.valueOf(1000) झूठी उपज
new Integer(1) == new Integer(1), झूठी निकलेगा के रूप में कैश यहाँ

2. इस्तेमाल नहीं किया है), तो इसके बजाय के मानचित्र होगा, अगर तब कोई डेटा संरचना है जैसे हैशटेबल ???

आप यह क्यों पूछ रहे हैं? HashTable है लेकिन चूंकि यह सिंक्रनाइज़ किया गया है, इसका अर्थ है HashMap से अधिक ओवरहेड, इसलिए जब तक आपको सॉर्टिंग की आवश्यकता नहीं है, तब तक आपको HashMap या TreeMap पर सिंक्रनाइज़ेशन स्टिक की आवश्यकता नहीं है।

3.) संपादक इंटीजर को अनावश्यक मुक्केबाजी क्यों देता है।

यह शायद सिर्फ इसलिए पठनीयता की (aInteger.valueOf(a) तुलना में कम है) है।

4.) क्यों m.put ("पहला", ए) काम करता है? क्योंकि मैं आदिम चर पारित कर रहा हूं और मानचित्र के रखे() केवल ऑब्जेक्ट को स्वीकार करते हैं। तो ऑटो मुक्केबाजी की वजह से यह है?

Answer 2

4.) क्यों m.put ("पहला", ए) काम करता है? क्योंकि मैं आदिम चर पारित कर रहा हूं और मानचित्र के रखे() केवल ऑब्जेक्ट को स्वीकार करते हैं।

Autoboxing।

पूर्णांक स्वचालित रूप से

3.) क्यों संपादक पूर्णांक के लिए अनावश्यक मुक्केबाजी देता है (इस मामले में संभव NullPointerException के साथ) पूर्णांक और उपाध्यक्ष प्रतिकूल में बदला जाता है।

क्योंकि आपको कोड का यह टुकड़ा लिखने की आवश्यकता नहीं है। कंपाइलर आपके लिए यह करेगा।

यह आमतौर पर अधिक पठनीय है

2.), तो इसके स्थान मानचित्र की है, अगर वहाँ HashTable की तरह किसी भी डेटा संरचना है, तो मामले में एक ही है ???

हाँ जेडीके संग्रह में हाँ केवल ऑब्जेक्ट्स के साथ काम करते हैं। इसका मतलब है कि आदिम प्रकारों को बॉक्स किया जाना चाहिए। इसमें एक छोटी रनटाइम लागत और एक विशाल मेमोरी ओवरहेड है। एक इंटीजर एक int की तुलना में ~ 300% अधिक स्मृति लेते हैं।

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

और अंत में कभी भी कभी भी पूर्ण इंटीजर (x) नहीं लिखते। Integer.valueOf (x) एक ही चीज़ करता है लेकिन यह कुछ सामान्य रूप से उपयोग किए गए मानों के लिए नए उदाहरण बनाने से बचने के लिए आंतरिक कैश को बनाए रखता है।