Java मध्ये long ला int मध्ये रूपांतरित कसे करायचे

या लेखात, आम्ही जावा मध्ये long ला int मध्ये रूपांतरित कसे करायचे आणि काही कोड उदाहरणे कशी लिहायची हे सांगणार आहोत . long हा int पेक्षा मोठा डेटा प्रकार असल्याने , येथे आपण अशा रूपांतरणासाठी type casting वापरावे. जावा मधील लाँग आणि इंट हे दोन्ही प्रिमिटिव्ह डेटा प्रकार आहेत हे तुम्हाला आधीच माहीत आहे . म्हणजे ते वर्गीय वस्तू नाहीत. सर्व ऑब्जेक्ट्स आणि अॅरे हेप स्पेसमध्ये साठवले जातात तर इंट आणि लाँग सारखे आदिम प्रकार स्टॅक मेमरीमध्ये संग्रहित केले जातात. लांब आणि इंट काहीसे समान आहेत. पूर्णांक म्हणजे पूर्ण संख्या, ती धन, ऋण किंवा शून्य असू शकते. दोन्ही लांबआणि int पूर्णांक प्रकार आहेत, म्हणून ते एका प्रकारे सुसंगत आहेत. समस्या अशी आहे की, लाँग प्रकार -263 ते 263 – 1, किंवा -9223372036854775808 ते 9223372036854775807 पर्यंत असतो. म्हणजेच जावा प्रोग्राम एका लांब प्रकारासाठी 64 बिट वाटप करतो. त्याच वेळी, int प्रकार 32 बिट्स व्यापतो, ज्यामध्ये तुम्ही -231 до 231 - 1 किंवा, जे समान आहे, -2147483648 ते 2147483647 पर्यंत संख्या ठेवू शकता. याचा अर्थ असा की int प्रकारची कोणतीही संख्या सहजपणे बसू शकते. लांब प्रकार. जावामध्ये, प्रिमिटिव्हसह काम करताना, अरुंद प्रकारातून विस्तीर्ण प्रकारात रूपांतरण स्वयंचलित आहे. दुसर्या प्रकारे, त्याला रुंदीकरण म्हणतात.

int myInt= 18;
long myLong= 16000;
       myLong = myInt;

येथे आपण एका लांब व्हेरिएबलला int नियुक्त करत आहोत . सर्व काही सहजतेने गेले, मोठ्या श्रेणीत, एक लहान शांतपणे बसते आणि आम्ही मेमरी स्पेसशिवाय काहीही गमावत नाही. तसे, जेव्हा आपण लाँग टाईपचे व्हेरिएबल घोषित करतो आणि त्याचे मूल्य परिभाषित करतो, तेव्हा त्याला l हे अक्षर नियुक्त करणे चांगले असते , जेव्हा आपण int श्रेणीबाहेरील संख्यांसह कार्य करतो तेव्हा हे उपयुक्त ठरेल .

long myVeryLong = 10000000000l;

जावा लाँग टू इंट रूपांतरण

आता या लेखाच्या मुख्य कार्याकडे वळूया — Java लाँग टू इंट रूपांतरण. समस्या अशी आहे की काहीतरी मोठे नेहमी लहान गोष्टीत बसत नाही. त्यामुळे येथे आपण Java मध्ये आपोआप “लहान” ला “मोठ्या” मध्ये टाकू शकत नाही. जर आपण मागील उदाहरणाप्रमाणे वागण्याचा प्रयत्न केला, परंतु उलट:

//example without typecasting…nice trying! 
public static void main(String[] args) {

int myInt= 18;
long myLong= 16000;
       myInt = myLong;
}

Java कंपाइलर आम्हाला हे करू देत नाही आणि त्रुटी टाकेल. तर या ऑपरेशनसाठी, आपल्याला टाइपकास्टिंग म्हणतात ते वापरावे लागेल. या प्रक्रियेला संकुचित प्रकार रूपांतरण म्हणतात. व्हेरिएबल संकुचित करण्यासाठी, तुम्हाला तुमचे मूल्य कोणत्या प्रकारात टाकायचे आहे ते स्पष्टपणे निर्दिष्ट करणे आवश्यक आहे. येथे एक उदाहरण आहे जिथे आपण एक "लहान" लांब ते इंट (ज्यामध्ये बसायला हवे) आणि दोन "मोठे" लांब संख्या इंट श्रेणीबाहेर ठेवण्याचा प्रयत्न करणार आहोत .

public class longToInt {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long myVeryLong = 2147483648l;//l in the end means ‘long’ 
       long myVeryLong = 10000000000l;

       myInt = (int) myLong;
       System.out.println(myInt);
       myInt = (int) oneMoreLong;
       System.out.println(myInt);
       myInt = (int) myVeryLong;
       System.out.println(myInt);
   }
}

आम्‍ही कंपायलरला सूचित केले आहे की आम्‍ही लाँग व्हॅल्यू इंट व्हेरिएबलमध्‍ये ठेवू इच्छितो आणि या निर्णयाच्या परिणामांसाठी आम्ही जबाबदार आहोत. संकलक, संकुचित प्रकाराचे स्पष्ट संकेत पाहून, रूपांतरण करतो. परिणामी, आम्हाला आउटपुट मिळते: बरं, 16000 हे नक्कीच आपल्याला अपेक्षित आहे, पण -2147483648 मध्ये उणे का आहे? आणि या 1410065408 चा अर्थ काय? वस्तुस्थिती अशी आहे की अशी संख्या एका लांब व्हेरिएबलमध्ये संग्रहित केली गेली होती, जी आपल्याला आठवते, 64 बिट घेते. आम्‍ही हे आकडे एका इंट व्हेरिएबलमध्‍ये ठेवण्‍याचा प्रयत्‍न करत आहोत जे केवळ 32 बिट साठवू शकतात. नियमानुसार, या 32 सेलमध्ये लांब संख्येच्या पहिल्या 32 बिट्समधील शून्य आणि एक असेल आणि बाकीचे टाकून दिले जातील. म्हणून, जर मूळ संख्या 32 बिट्समध्ये बसत नसेल, तर जे बिट्स बसत नाहीत ते टाकून दिले जातात. म्हणूनच आमच्याकडे फक्त 16000 ही योग्य संख्या आहे, कारण ती 32 पेक्षा कमी बिट घेते.

Java 8 लाँग टू इंट रूपांतरण

Java 8 मध्ये, मॅथ क्लासमध्ये एक नवीन पद्धत आहे जी long ला int मध्ये रूपांतरित करेल . येथे आहे:

Math.toIntExact(value);

या पद्धतीची सर्वोत्कृष्ट गोष्ट अशी आहे की ती रूपांतरित संख्येची लांबी नियंत्रित करते आणि जर मूल्य int मध्ये बसण्यासाठी खूप मोठे असेल तर ते अपवाद करेल. हे आमच्या उदाहरणात कसे कार्य करते ते पाहूया:

public class intToLong {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long oneMoreLong = 2147483648l;
       long myVeryLong = 10000000000l;
      
       System.out.println(Math.toIntExact(myLong));
       int y = Math.toIntExact(oneMoreLong);
       System.out.println(oneMoreLong);
       System.out.println(Math.toIntExact(myVeryLong));
   }
}

आउटपुट आहे: अशाप्रकारे, प्रोग्रामने फक्त योग्यरित्या रूपांतरित केलेला क्रमांक 16000 मुद्रित केला आणि नंतर श्रेणीबाहेरील क्रमांक 2147483648l ला int मध्ये ढकलण्याचा प्रयत्न करताना , पद्धतीने अपवाद केला. त्यामुळे क्लासिक Java लाँग टू इंट कन्व्हर्जनच्या बाबतीत आम्हाला टाकून दिलेल्या बिट्सची समस्या नाही .