आदिम प्रकारों का चौड़ीकरण और संकीर्णता

नमस्ते! जैसा कि आप CodeGym के माध्यम से आगे बढ़े हैं, आपने कई बार आदिम प्रकारों का सामना किया है। हम उनके बारे में जो जानते हैं, उसकी एक छोटी सूची यहां दी गई है:

1. वे वस्तु नहीं हैं और स्मृति में संग्रहीत मूल्य का प्रतिनिधित्व करते हैं
2. कई तरह के होते हैं
   • पूर्ण संख्याएँ: बाइट , शॉर्ट , इंट , लॉन्ग
   • फ़्लोटिंग-पॉइंट (आंशिक) संख्याएँ: फ़्लोट और डबल
   • तार्किक मूल्य: बूलियन
   • प्रतीकात्मक मूल्य (अक्षरों और अंकों का प्रतिनिधित्व करने के लिए): चार

3. प्रत्येक प्रकार के मूल्यों की अपनी सीमा होती है:

लेकिन अलग-अलग मूल्य होने के अलावा, वे इस बात में भी भिन्न होते हैं कि वे मेमोरी में कितनी जगह घेरते हैं। एक इंट एक बाइट से अधिक लेता है। और एक लंबा छोटा से बड़ा है। आदिम द्वारा कब्जा की गई मेमोरी की मात्रा की तुलना रूसी नेस्टिंग डॉल से की जा सकती है: प्रत्येक नेस्टिंग डॉल के अंदर जगह उपलब्ध होती है। घोंसला बनाने वाली गुड़िया जितनी बड़ी होती है, उतनी ही अधिक जगह होती है। एक बड़ी घोंसला बनाने वाली गुड़िया ( लंबी ) आसानी से एक छोटे से व्यक्ति को समायोजित करेगी । यह आसानी से फिट हो जाता है और आपको कुछ और करने की जरूरत नहीं है। जावा में, आदिम के साथ काम करते समय, इसे निहित रूपांतरण कहा जाता है। या अलग तरीके से कहें तो इसे चौड़ा करना कहते हैं।

जावा में विस्तार

यहाँ विस्तृत रूपांतरण का एक सरल उदाहरण दिया गया है:

public class Main {

   public static void main(String[] args) {

       int bigNumber = 10000000;

       byte littleNumber = 16;

       bigNumber = littleNumber;
       System.out.println(bigNumber);
   }
}

यहां हम एक int वेरिएबल को एक बाइट मान असाइन करते हैं । असाइनमेंट बिना किसी समस्या के सफल होता है: एक बाइट में संग्रहीत मूल्य एक इंट को समायोजित करने की तुलना में कम मेमोरी लेता है। छोटी नेस्टिंग डॉल (बाइट वैल्यू) बड़ी नेस्टिंग डॉल ( इंट वेरिएबल) के अंदर आसानी से फिट हो जाती है। यह अलग बात है अगर आप इसके विपरीत करने की कोशिश करते हैं, यानी एक बड़े मूल्य को एक चर में डालने के लिए जिसकी सीमा इतने बड़े डेटा प्रकार को समायोजित नहीं कर सकती है। असली घोंसले वाली गुड़िया के साथ, संख्या बस फिट नहीं होगी। जावा के साथ, यह हो सकता है, लेकिन बारीकियों के साथ। आइए एक int को एक छोटे चर में डालने का प्रयास करें :

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = bigNumber;// Error!
   System.out.println(bigNumber);
}

गलती! कंपाइलर समझता है कि आप एक बड़ी नेस्टिंग डॉल ( int ) को एक छोटे ( शॉर्ट ) के अंदर धकेल कर कुछ असामान्य करने की कोशिश कर रहे हैं । इस मामले में, संकलन त्रुटि संकलक से एक चेतावनी है: "अरे, क्या आप बिल्कुल निश्चित हैं कि आप ऐसा करना चाहते हैं?" यदि आप निश्चित हैं, तो आप संकलक को बताते हैं: "सब कुछ ठीक है। मुझे पता है कि मैं क्या कर रहा हूँ!" इस प्रक्रिया को स्पष्ट प्रकार का रूपांतरण या संकुचन कहा जाता है।

जावा में संकीर्णता

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

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = (short) bigNumber;
   System.out.println(littleNumber);
}

हम स्पष्ट रूप से इंगित करते हैं कि हम int को एक छोटे चर में रखना चाहते हैं और हम जिम्मेदारी लेंगे। यह देखते हुए कि एक संकरा प्रकार स्पष्ट रूप से इंगित किया गया है, संकलक रूपांतरण करता है। परिणाम क्या है? कंसोल आउटपुट: -27008 यह थोड़ा अप्रत्याशित था। हमें ऐसा क्यों मिला? वास्तव में, यह सब बहुत आसान है। मूल रूप से, मूल्य 10000000 था यह एक अंतर चर में संग्रहीत किया गया था, जो 32 बिट्स पर कब्जा कर लेता है। यह इसका द्विआधारी प्रतिनिधित्व है: हम इस मान को एक छोटे चर में लिखते हैं, जो केवल 16 बिट स्टोर कर सकता है! तदनुसार, हमारी संख्या के केवल पहले 16 बिट ही वहां स्थानांतरित किए जाएंगे। बाकी को खारिज कर दिया जाएगा। नतीजतन, लघु चर निम्न मान प्राप्त करता है जो दशमलव रूप में -27008 के बराबर है यही कारण है कि संकलक आपको एक विशिष्ट प्रकार के स्पष्ट संकुचन रूपांतरण का संकेत देकर "पुष्टि" करने के लिए कहता है। सबसे पहले, यह दर्शाता है कि आप परिणाम की जिम्मेदारी ले रहे हैं। और दूसरा, यह कंपाइलर को बताता है कि कन्वर्ट करते समय कितनी जगह आवंटित करनी है। आखिरकार, पिछले उदाहरण में, यदि हमने शॉर्ट के बजाय बाइट वेरिएबल को एक इंट मान दिया है , तो हमारे पास केवल 8 बिट्स होंगे, न कि 16, और परिणाम अलग होगा। रूपांतरणों को कम करने के लिए आंशिक प्रकार ( फ्लोट और डबल ) की अपनी प्रक्रिया होती है। यदि आप एक पूर्णांक प्रकार के लिए एक भिन्नात्मक संख्या को कास्ट करने का प्रयास करते हैं, तो भिन्नात्मक भाग को छोड़ दिया जाएगा।

public static void main(String[] args) {

   double d = 2.7;

   long x = (int) d;
   System.out.println(x);
}

कंसोल आउटपुट: 2

चार

आप पहले से ही जानते हैं कि चार का उपयोग अलग-अलग वर्णों को प्रदर्शित करने के लिए किया जाता है।

public static void main(String[] args) {

   char c = '!';
   char z = 'z';
   char i = '8';

}

लेकिन इस डेटा प्रकार में कई विशेषताएं हैं जिन्हें समझना महत्वपूर्ण है। आइए मूल्य श्रेणियों की तालिका पर फिर से नज़र डालें: चार प्रकार के लिए 0 से 65536 की सीमा इंगित की गई है । लेकिन इसका क्या मतलब है? आखिरकार, एक चार न केवल संख्याओं का प्रतिनिधित्व करता है, बल्कि अक्षरों, विराम चिह्नों का भी प्रतिनिधित्व करता है ... बात यह है कि जावा में चार मूल्यों को यूनिकोड प्रारूप में संग्रहीत किया जाता है। पिछले पाठों में से एक में हम पहले ही यूनिकोड का सामना कर चुके हैं। आपको शायद याद होगा कि यूनिकोड एक वर्ण एन्कोडिंग मानक है जिसमें दुनिया की लगभग सभी लिखित भाषाओं के प्रतीक शामिल हैं। दूसरे शब्दों में, यह विशेष कोड की एक सूची है जो किसी भी भाषा में लगभग हर वर्ण का प्रतिनिधित्व करती है। संपूर्ण यूनिकोड तालिका बहुत बड़ी है, और निश्चित रूप से, इसे कंठस्थ करने की कोई आवश्यकता नहीं है। यहाँ इसका एक छोटा सा हिस्सा है: मुख्य बात यह समझना है कि वर्ण कैसे संग्रहीत किए जाते हैं, और याद रखें कि यदि आप किसी विशेष वर्ण के लिए कोड जानते हैं, तो आप हमेशा अपने कार्यक्रम में उस वर्ण का उत्पादन कर सकते हैं। आइए कुछ यादृच्छिक संख्या के साथ प्रयास करें:

public static void main(String[] args) {

   int x = 32816;

   char c = (char) x ;
   System.out.println(c);
}

कंसोल आउटपुट: 耰 यह जावा में char s को स्टोर करने के लिए उपयोग किया जाने वाला प्रारूप है । प्रत्येक प्रतीक एक संख्या से मेल खाता है: एक 16-बिट (दो-बाइट) संख्यात्मक कोड। यूनिकोड में, 32816 चीनी वर्ण 耰 से मेल खाता है। निम्नलिखित बिंदु पर ध्यान दें। इस उदाहरण में, हमने एक int वेरिएबल का उपयोग किया है। यह स्मृति में 32 बिट्स पर कब्जा कर लेता है, जबकि एक चर 16 पर कब्जा कर लेता है। यहां हमने एक int चुना है, क्योंकि हमारी संख्या (32816) संक्षेप में फिट नहीं होगी । हालाँकि एक char का आकार (बिल्कुल छोटा ) 16 बिट का होता है, लेकिन char श्रेणी में कोई ऋणात्मक संख्या नहीं होती है , इसलिए char का "सकारात्मक" भागरेंज दोगुनी बड़ी है ( लघु प्रकार के लिए 32767 के बजाय 65536)। जब तक हमारा कोड 65536 से नीचे रहता है तब तक हम एक इंट का उपयोग कर सकते हैं। और इसका परिणाम संकुचित रूपांतरण होगा

char c = (char) x;

अतिरिक्त बिट्स को छोड़ दिया जाएगा (जैसा कि ऊपर चर्चा की गई है) और परिणाम काफी अप्रत्याशित होगा।

वर्ण और पूर्णांक जोड़ने की विशेष सुविधाएँ

आइए एक असामान्य उदाहरण देखें:

public class Main {

   public static void main(String[] args) {

      char c = '1';

      int i = 1;

       System.out.println(i + c);
   }
}

कंसोल आउटपुट: 50 O_О यह कैसे समझ में आता है? 1+1। 50 कहाँ से आए ?! आप पहले से ही जानते हैं कि charमान स्मृति में 0 से 65536 तक की संख्या के रूप में संग्रहीत होते हैं, और ये संख्या एक वर्ण का एक यूनिकोड प्रतिनिधित्व है। जब हम एक चार और कुछ पूर्णांक प्रकार जोड़ते हैं, तो चार को संबंधित यूनिकोड संख्या में बदल दिया जाता है। हमारे कोड में, जब हमने 1 और '1' जोड़ा, तो प्रतीक '1' को उसके अपने कोड में बदल दिया गया, जो कि 49 है (आप इसे ऊपर की तालिका में सत्यापित कर सकते हैं)। इसलिए, परिणाम 50 है। आइए एक बार फिर से अपने पुराने मित्र 耰 को एक उदाहरण के रूप में लेते हैं, और इसे किसी संख्या में जोड़ने का प्रयास करते हैं।

public static void main(String[] args) {

   char c = '耰';
   int x = 200;

   System.out.println(c + x);
}

कंसोल आउटपुट: 33016 हमने पहले ही पता लगा लिया है कि 耰 32816 के अनुरूप है। और जब हम इस संख्या और 200 को जोड़ते हैं, तो हमें अपना परिणाम मिलता है: 33016। :) जैसा कि आप देख सकते हैं, यहाँ एल्गोरिथ्म काफी सरल है, लेकिन आपको इसे नहीं भूलना चाहिए .