संख्या (पूर्णांक, लांब, बाइट)

"विकासक संख्यांचे वर्णन करणारे वर्ग आणू शकत असल्याने, त्यांनी वास्तविक विकासकांप्रमाणे सर्जनशील होण्याचा निर्णय घेतला."

"प्रथम, त्यांनी एक अमूर्त संख्या वर्ग आणला, ज्यामधून बाइट, शॉर्ट, इंटीजर, लाँग, फ्लोट आणि डबल काढले जातात. त्यात अशा पद्धती आहेत ज्या संख्यांना इतर संख्यात्मक प्रकारांमध्ये रूपांतरित करण्यात मदत करतात."

int intValue()

long longValue()

float floatValue()

double doubleValue()

byte byteValue()

short shortValue()

"बरोबर. शेवटी, तुम्ही हे लिहू शकत नाही:"

Long x = 100000;
Integer y = (Integer) x;

"हो, हे प्रकार आदिम नाहीत. म्हणूनच आम्ही संख्या वर्गाच्या पद्धती वापरतो:"

Long x = 100000;
Integer y = x.intValue();

"परंतु अजूनही काही गोष्टी विचारात घ्यायच्या आहेत. कारण पूर्णांक एक int नाही, पूर्णांक वस्तूंची क्लासिक «==» ऑपरेटरशी तुलना केली जाऊ शकत नाही."

int x = 500;
int y = 500;
x == y; //true

Integer x = 500;
Integer y = 500;
x == y; //false
x.equals(y); //true

"नक्की. कसा तरी मी लगेच विचार केला नाही."

"पण अजून काही आहे."

"तुम्ही माझे सर्किट शॉर्टिंग करत आहात! अजून काय आहे?"

"जेव्हा आपण Integer व्हेरिएबलला int मूल्य नियुक्त करतो, तेव्हा Integer.valueOf पद्धतीला म्हणतात:"

Integer x = 5;

Integer x = Integer.valueOf(5);

"हो, मला वरील उदाहरणावरून ते आधीच समजले आहे."

"परंतु, valueOf फंक्शन नेहमी नवीन पूर्णांक ऑब्जेक्ट तयार करत नाही."

"अरे, तुला काय म्हणायचे आहे «नेहमी नाही»?"

"हे -128 ते 127 पर्यंत मूल्ये कॅश करते."

Integer x = 300;
Integer y = 300;
Integer z = 300;

Integer x = Integer.valueOf(300);
Integer y = Integer.valueOf(300);
Integer z = Integer.valueOf(300);

Integer x = 100;
Integer y = 100;
Integer z = 100;

Integer x = Integer.valueOf(100);
Integer y = Integer.valueOf(100);
Integer z = Integer.valueOf(100);

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = 10;
Integer t = 10;

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = Integer.valueOf(10);
Integer t = Integer.valueOf(10);

"दुसर्‍या शब्दात, परिस्थिती अशी आहे:"

1)  जर आपण "नवीन पूर्णांक()" लिहिल्यास, आपल्याला नवीन ऑब्जेक्ट मिळण्याची हमी आहे.

2)  जर आपण Integer.valueOf(), स्पष्टपणे किंवा ऑटोबॉक्सिंगद्वारे कॉल केला, तर नंबर आर्ग्युमेंट -128 ते 127 च्या श्रेणीत असल्यास पद्धत नवीन ऑब्जेक्ट किंवा कॅशे केलेले ऑब्जेक्ट देऊ शकते.

"कॅशेमधून ऑब्जेक्ट परत करण्याच्या पद्धतीबद्दल इतके भयंकर काय आहे?"

"काही हरकत नाही. तुम्हाला फक्त हे माहित असणे आवश्यक आहे की काहीवेळा, जेव्हा तुमची अपेक्षा नसते, तेव्हा वस्तू समान असू शकतात. समानतेसह सर्व काही क्लिष्ट आहे. जर आपण आदिमची तुलना नॉन-प्रिमिटिवशी केली, तर त्यांची तुलना आदिम म्हणून केली जाईल:"

int x = 300;
Integer y = 300;
Integer z = 300;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references)

int x = 100;
Integer y = 100;
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //true (comparison based on references; they point to the same object)

int x = 100;
Integer y = new Integer(100);
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references; they point to different objects)

"छान... आणि मी हे सगळं कसं लक्षात ठेवणार?"

"तुम्हाला हे लक्षात ठेवण्याची गरज नाही. तुम्हाला फक्त हे समजून घेणे आवश्यक आहे की हे सर्व कसे आयोजित केले जाते आणि जेव्हा एखादा आदिम आणि त्याचा गैर-आदिमीय समकक्ष कार्यात येतो तेव्हा प्रत्यक्षात काय होते."

"मी देखील शिफारस करतो की तुम्ही पूर्णांक वर्गाच्या पद्धती पहा. त्यात बर्‍याच चांगल्या आणि उपयुक्त पद्धती आहेत. तुम्ही त्यापैकी एकाचा वापरही केला आहे."

"हो, मला आठवते. Integer.parseInt();"