जावा एक दृढ़ता से टाइप की जाने वाली भाषा है, लेकिन विभिन्न प्रकार के आदिम चर के बीच मूल्यों को स्थानांतरित करना अभी भी संभव है। उदाहरण के लिए, मैं किसी भी समस्या के बिना एक इंट के मान को डबल तक असाइन कर सकता हूं, जब तक कि मान प्राप्त करने वाले प्रकार की भंडारण क्षमता इसे संभाल सकती है।

प्रत्येक आदिम प्रकार का आकार नीचे देखें:

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

लेकिन क्या होगा यदि मैं मूल्य को कम भंडारण क्षमता वाले प्रकार में स्थानांतरित करना चाहता हूं? जावा कंपाइलर को यह पसंद नहीं है, लेकिन यदि आप इसे कास्ट करते हैं तो यह इसकी अनुमति देगा, जैसा कि नीचे दिए गए उदाहरण में है।

double decimal = 65.9;
int i = (int) decimal; //aqui ele perde a casa decimal e vira 65
char c = (char) i; //aqui ele vira a letra A (que corresponde a 65)

यदि नए प्रकार में जाने वाले मूल्य का आकार उस प्रकार की सीमा से अधिक है, तो कुछ अधिक नाटकीय हो सकता है। एक int i = 10 एक बाइट वेरिएबल में फिट बैठता है, क्योंकि इसमें -128 से 127 तक की रेंज में 8 बिट्स होते हैं। हालाँकि, अगर मैं टाइप बाइट के एक वेरिएबल में एक int i = 128 डालना चाहता हूं तो क्या होगा...वहां होगा जानकारी का नुकसान .

public class Main
{
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;

        System.out.println(b); // o valor de b agora é -128 :S
    }
}

ऑटोबॉक्सिंग

पिछली पोस्ट में [इसे यहां पढ़ें], मैंने रैपर कक्षाओं के बारे में थोड़ी बात की थी। उदाहरण के तौर पर, मैंने Integer.parse(i) लिखा था = कल्पना करें कि i एक प्रकार है
आदिम इंट.

वर्तमान में, रैपर पार्स विधि का उपयोग अब प्रोत्साहित नहीं किया जाता है क्योंकि इसे अस्वीकृत कर दिया गया है। किसी प्रिमिटिव को रैपर क्लास में बदलने के लिए और, इस तरह, अंतर्निहित तरीकों का उपयोग करने के लिए, "ऑटोबॉक्सिंग" करने की अनुशंसा की जाती है, जैसा कि उदाहरण में है:

Character ch = 'a';
Integer i = 10;

ध्यान दें कि यह अधिक सीधा दृष्टिकोण है। आप बस एक ही बार में सभी मान निर्दिष्ट कर देते हैं।

इसके विपरीत करने और डेटा को एक आदिम प्रकार के रूप में वापस करने के लिए, आप valueOf:
विधि का उपयोग करके "अनबॉक्सिंग" कर सकते हैं

Integer i = 10;
int j = Integer.valueOf(i);

जैसा कि मैंने पिछली पोस्ट में कहा था, आदिम का रैपर बनाने से आपको क्लास के तरीकों का उपयोग करने की सुविधा मिलती है और डेटा के साथ काम करते समय जीवन आसान हो जाता है।

किसी प्रिमिटिव का रैपर संस्करण पहली नज़र में काफी हद तक उसके जैसा लग सकता है, लेकिन जेवीएम किसी ऑब्जेक्ट और प्रिमिटिव के साथ एक जैसा व्यवहार नहीं करता है, मत भूलिए। याद रखें कि आदिम लोग स्टैक पर जाते हैं और ऑब्जेक्ट ढेर पर जाते हैं [यहां याद रखें]।

प्रदर्शन के संदर्भ में, यह स्पष्ट है कि आदिम से डेटा पुनर्प्राप्त करना कंप्यूटर के लिए कम महंगा है, क्योंकि मूल्य सीधे संग्रहीत किया जाता है, संदर्भ द्वारा नहीं। टुकड़ों को मेमोरी में एक साथ रखने की तुलना में तैयार डेटा प्राप्त करना कहीं अधिक तेज़ है।

लेकिन ऐसे मामले भी हैं जहां रैपर का उपयोग करना आवश्यक होगा। उदाहरण के लिए, जब आप ArrayList क्लास के साथ काम करना चाहते हैं। यह केवल वस्तुओं को पैरामीटर के रूप में स्वीकार करता है, आदिम मानों के रूप में नहीं।

आदिम से वस्तु और इसके विपरीत में यह परिवर्तन भाषा के बारे में जो लचीलापन लाता है वह वास्तव में अच्छा है। लेकिन हमें यहां और कई अन्य चर्चाओं के बारे में जागरूक होने की जरूरत है।

बस समाज को चौंका देने के लिए (हंसना), मैं एक समस्याग्रस्त मामले का उदाहरण देने जा रहा हूं जिसमें ओवरलोडिंग के साथ काम करते समय एक कोड का अप्रत्याशित व्यवहार शामिल है (मैंने अभी तक ओवरलोडिंग के बारे में कोई पोस्ट नहीं किया है, लेकिन मैं बनाऊंगा। मूल रूप से, ओवरलोडिंग तब होती है जब किसी विधि में अलग-अलग हस्ताक्षर होते हैं)।

इस मामले का उल्लेख जोशुआ बलोच की पुस्तक "इफेक्टिव जावा" में किया गया था।

public class SetListTest {
    public static void main(String[] args) {
        Set set = new TreeSet();
        List list = new ArrayList();

        for (int i = -3; i 



इस कार्यक्रम में, उद्देश्य एक सेट और एक सूची में -3 ​​से 2 [-3, -2, -1, 0, 1, 2] तक पूर्णांक मान जोड़ना था। फिर सकारात्मक मान [0, 1 और 2] हटा दें। लेकिन, यदि आप इस कोड को चलाते हैं, तो आप देखेंगे कि सेट और सूची ने समान परिणाम प्रस्तुत नहीं किए। जैसा कि अपेक्षित था, सेट [-3, -2, -1] लौटाता है। सूची रिटर्न [-2, 0, 2]।

ऐसा इसलिए होता है क्योंकि लिस्ट क्लास की बिल्ट-इन रिमूव(i) पद्धति पर कॉल i को एक आदिम प्रकार int के रूप में मानता है, और कुछ नहीं। यह विधि, बदले में, i स्थिति से तत्वों को हटा देती है।

सेट क्लास की रिमूव (i) विधि के लिए कॉल एक ओवरलोड को कॉल करता है जो पैरामीटर के रूप में एक इंटीजर ऑब्जेक्ट प्राप्त करता है, स्वचालित रूप से i, जो मूल रूप से एक इंट था, को इंटीजर में परिवर्तित करता है। इस पद्धति का व्यवहार, बदले में, उन सेट तत्वों को बाहर कर देता है जिनका मान i के बराबर है (और i के बराबर सूचकांक नहीं) - ध्यान दें कि सेट और सूची दोनों के लिए अपेक्षित प्रकार पूर्णांक था। (सेट सेट / सूची सूची)। इसीलिए सेट क्लास की रिमूव विधि के लिए चुनी गई ओवरलोडिंग ने इसे इंटीजर में बदल दिया।

जबकि सूची में हटाने का व्यवहार सूचकांक द्वारा हटाना है, सेट में हटाने का व्यवहार मूल्य के अनुसार हटाना है। यह सब इंटीजर प्राप्त करने वाले रिमूव के ओवरलोडिंग के कारण है।