जावा में लॉन्ग को इंट में कैसे कन्वर्ट करें

इस लेख में, हम यह बताने जा रहे हैं कि जावा में लॉन्ग को इंट में कैसे बदलें और कुछ कोड उदाहरण लिखें। चूँकि long int से बड़ा डेटा प्रकार है , यहाँ हमें इस तरह के रूपांतरण के लिए टाइप कास्टिंग का उपयोग करना चाहिए। जैसा कि आप शायद पहले से ही जानते हैं कि जावा में लंबे और इंट दोनों आदिम डेटा प्रकार हैं। इसका मतलब है कि वे क्लास ऑब्जेक्ट नहीं हैं। सभी वस्तुओं और सरणियों को हीप स्पेस में संग्रहीत किया जाता है जबकि आदिम प्रकार जैसे कि इंट और लॉन्ग को स्टैक मेमोरी में संग्रहीत किया जाता है। लंबा और int कुछ हद तक समान हैं। पूर्णांक का अर्थ है पूर्ण संख्या, जो धनात्मक, ऋणात्मक या शून्य हो सकती है। दोनों लंबेतथा int पूर्णांक प्रकार हैं, इसलिए वे एक तरह से संगत हैं। समस्या यह है, कि लंबे प्रकार की सीमा -263 से 263 - 1, या -9223372036854775808 से 9223372036854775807 तक होती है। यानी, जावा प्रोग्राम एक लंबे प्रकार के लिए 64 बिट्स आवंटित करता है। उसी समय, int प्रकार 32 बिट्स पर कब्जा कर लेता है, जिसमें आप -231 से 231 - 1 तक संख्याएँ डाल सकते हैं या, जो -2147483648 से 2147483647 तक समान है । लंबा प्रकार। जावा में, आदिम के साथ काम करते समय, संकीर्ण प्रकार से व्यापक प्रकार में रूपांतरण स्वचालित होता है। दूसरे प्रकार से इसे चौड़ा करना कहते हैं।

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

यहां हम एक लंबे चर के लिए एक इंट असाइन कर रहे हैं। सब कुछ सुचारू रूप से चला गया, एक बड़ी रेंज में, एक छोटा चुपचाप फिट बैठता है और हम मेमोरी स्पेस के अलावा कुछ भी नहीं खोते हैं। वैसे, जब हम लंबे प्रकार के एक चर की घोषणा करते हैं और इसके मूल्य को परिभाषित करते हैं, तो इसे अक्षर एल असाइन करना बेहतर होता है , यह तब काम आएगा जब हम इंट रेंज के बाहर संख्याओं के साथ काम करेंगे।

long myVeryLong = 10000000000l;

जावा लॉन्ग टू इंट कन्वर्जन

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

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

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

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

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 बिट से कम समय लगता है।

जावा 8 लंबे समय तक इंट रूपांतरण

जावा 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 में धकेलने का प्रयास करते समय , विधि ने एक अपवाद फेंक दिया। इसलिए हमें छोड़े गए बिट्स की समस्या नहीं है, जैसा कि क्लासिक जावा लॉन्ग टू इंट कन्वर्जन के मामले में है।