ऑब्जेक्ट्स की सरणी Java

ऑब्जेक्ट्स का ऐरे क्या होता है? Java?

A Java वस्तुओं की सरणी यह एक ही निश्चित आकार के कंटेनर में एक ही क्लास के कई ऑब्जेक्ट इंस्टेंस को स्टोर करता है। प्रिमिटिव ऐरे के विपरीत, जो इस प्रकार के मानों को स्टोर करता है। int, doubleया, boolean प्रत्येक स्लॉट में सीधे तौर पर, ऑब्जेक्ट्स का एक ऐरे संग्रहीत होता है। संदर्भप्रत्येक स्लॉट किसी ऑब्जेक्ट के मेमोरी स्थान को इंगित करता है, और ऑब्जेक्ट स्वयं उस मेमोरी स्थान पर मौजूद होता है। Java ढेर।

यह लेआउट किसी भी वस्तु के अनुरूप है परिवर्तनशील in Java यह काम करता है। ऐरे कई ऑब्जेक्ट रेफरेंस को एक साथ समूहित करता है ताकि आप उन्हें इंडेक्स द्वारा एक्सेस कर सकें। यह तब सबसे उपयुक्त विकल्प है जब ऑब्जेक्ट की संख्या पहले से ज्ञात हो और प्रोग्राम के जीवनकाल के दौरान न बदले।

वाक्य - विन्यास

ClassName[] obj = new ClassName[array_length];

दाईं ओर जगह आवंटित की गई है array_length संदर्भ, सभी आरंभ किए गए nullकोई वस्तु नहीं ClassName अभी तक केवल ऐसा कंटेनर मौजूद है जो ऐसी वस्तुओं के संदर्भों को धारण कर सकता है।

ऑब्जेक्ट्स का ऐरे कैसे बनाएं Java

ऑब्जेक्ट्स का एक कार्यशील ऐरे बनाने में हमेशा दो आवंटन चरण लगते हैं। पहला चरण संदर्भ कंटेनर को आवंटित करता है, और दूसरा चरण उन सभी ऑब्जेक्ट्स को आवंटित करता है जिन्हें कंटेनर इंगित करेगा।ping दूसरा चरण सबसे आम स्रोत है NullPointerException शुरुआती Java कोड।

चरण 1) अपनी खोलो कोड संपादक और निम्नलिखित कोड को कॉपी करें:

class ObjectArray {
    public static void main(String args[]) {
        Account obj[] = new Account[2];
        // obj[0] = new Account();
        // obj[1] = new Account();
        obj[0].setData(1, 2);
        obj[1].setData(3, 4);
        System.out.println("For Array Element 0");
        obj[0].showData();
        System.out.println("For Array Element 1");
        obj[1].showData();
    }
}

class Account {
    int a;
    int b;

    public void setData(int c, int d) {
        a = c;
        b = d;
    }

    public void showData() {
        System.out.println("Value of a = " + a);
        System.out.println("Value of b = " + b);
    }
}

चरण 2) फ़ाइल को इस रूप में सहेजें ObjectArray.javaफिर इसे कंपाइल और रन करें।

चरण 3) त्रुटि पर ध्यान दें। चरण 4 पर आगे बढ़ने से पहले इसे ठीक करने का प्रयास करें।

चरण 4) लाइन का निरीक्षण करें Account obj[] = new Account[2];यह दो संदर्भ चरों की एक सरणी आवंटित करता है। Accountलेकिन यह किसी भी प्रकार का आवंटन नहीं करता है। Account वस्तुएं। दोनों स्लॉट में वस्तुएं रखी जा सकती हैं। nullऔर बुला रहा है obj[0].setData(...) एक पर null संदर्भ एक त्रुटि उत्पन्न करता है NullPointerException चलने के समय पर।

चरण 5) पंक्ति 4 और 5 को अनकमेंट करें। ये दोनों पंक्तियाँ वास्तविक Account ऑब्जेक्ट और उन्हें असाइन करें obj[0] और obj[1]अब ऐरे में वास्तविक संदर्भ मौजूद हैं, और कोड सुचारू रूप से चलता है।

आउटपुट:

For Array Element 0
Value of a = 1
Value of b = 2
For Array Element 1
Value of a = 3
Value of b = 4

ऑब्जेक्ट्स के ऐरे को कैसे इनिशियलाइज़ करें Java

ऊपर दिखाए गए सेटर-आधारित आरंभीकरण के अलावा, ऑब्जेक्ट्स के एक ऐरे को तीन सरल तरीकों से आरंभ किया जा सकता है। प्रत्येक तरीका स्पष्टता के लिए शब्दों की अधिकता को कम करता है, इसलिए वह तरीका चुनें जो स्थिति के लिए सबसे उपयुक्त हो।

1. लूप आरंभीकरण — ऐरे को एलोकेट करें, फिर प्रत्येक इंडेक्स पर जाएं और एक नया ऑब्जेक्ट असाइन करें। यह बड़े ऐरे के लिए या जब ऑब्जेक्ट की संख्या गतिशील हो, तब मानक पैटर्न है।
2. कंस्ट्रक्टर आरंभीकरण — निर्माण के समय ही मानों को सीधे कंस्ट्रक्टर को पास करें, इसलिए अलग से सेटर कॉल की आवश्यकता नहीं है।
3. ऐरे लिटरल आरंभीकरण — एक ही स्टेटमेंट में इनलाइन कमांड का उपयोग करके घोषणा और डेटा भरें { ... } आरंभकर्ता, छोटे निश्चित सेटों के लिए आदर्श।

class Account {
    int a, b;

    public Account(int a, int b) {   // constructor
        this.a = a;
        this.b = b;
    }
}

public class InitDemo {
    public static void main(String[] args) {

        // 1) Loop initialisation
        Account[] loopArr = new Account[3];
        for (int i = 0; i < loopArr.length; i++) {
            loopArr[i] = new Account(i, i * 10);
        }

        // 2) Constructor initialisation, one slot at a time
        Account[] ctorArr = new Account[2];
        ctorArr[0] = new Account(1, 2);
        ctorArr[1] = new Account(3, 4);

        // 3) Array literal initialisation
        Account[] litArr = {
            new Account(5, 6),
            new Account(7, 8),
            new Account(9, 10)
        };

        System.out.println("loop size   = " + loopArr.length);
        System.out.println("ctor size   = " + ctorArr.length);
        System.out.println("literal size= " + litArr.length);
    }
}

लूप आरंभीकरण सबसे सुरक्षित डिफ़ॉल्ट विकल्प है क्योंकि यह सुनिश्चित करता है कि कोई भी स्लॉट खाली न रहे। nullकंस्ट्रक्टर इनिशियलाइज़ेशन से यह स्पष्ट हो जाता है कि प्रत्येक ऑब्जेक्ट को अलग-अलग आर्गुमेंट्स की आवश्यकता है, और ऐरे लिटरल छोटे डेमो कोड को कॉम्पैक्ट रखते हैं। जब तक कोई कारण न हो, एक ही ऐरे में अलग-अलग शैलियों का प्रयोग न करें: एकरूपता से बग्स को पहचानना आसान हो जाता है।

किसी ऑब्जेक्ट में तत्वों को दोहराना और उन तक पहुंचना Java ऑब्जेक्ट्स की सरणी

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

क्लासिक for पाश यह इंडेक्स तक पहुंच प्रदान करता है, जो तत्वों को बदलने, पड़ोसियों की तुलना करने या उपश्रेणी को दोहराने के लिए उपयोगी है।

for (int i = 0; i < obj.length; i++) {
    System.out.println("Element " + i);
    obj[i].showData();
}

वर्धित for पाश (“फॉर-ईच” लूप) इंडेक्स को छुपा देता है और जब इंडेक्स की आवश्यकता नहीं होती है तो अधिक स्वाभाविक रूप से पढ़ता है:

for (Account acc : obj) {
    acc.showData();
}

धाराएँ (Java 8 और उसके बाद) ऐरे को पाइपलाइन में बदलें, जो फ़िल्टरिंग और मैपिंग के लिए उपयोगी है।pingया फिर लूप लिखे बिना एग्रीगेट करना:

import java.util.Arrays;

Arrays.stream(obj)
      .filter(acc -> acc.a > 0)
      .forEach(Account::showData);

किसी एक तत्व को पढ़ने या अपडेट करने के लिए, सीधे इंडेक्स एक्सेस का उपयोग करें, उदाहरण के लिए obj[1].setData(10, 20)लंबाई की पहले हमेशा जांच कर लें। obj.length बचने के लिए ArrayIndexOutOfBoundsExceptionजब कोई भी स्लॉट हो सकता है nullनल चेक या किसी अन्य सुरक्षा उपाय से पहुंच को सुरक्षित करें। Optional प्रोग्राम को क्रैश होने से बचाने के लिए उसे लगातार चालू रखना।

ऑब्जेक्ट्स की ऐरे बनाम ऑब्जेक्ट्स की ऐरेलिस्ट Java

ऑब्जेक्ट्स का एक साधारण ऐरे तेज़ और अनुमानित होता है, लेकिन रनटाइम पर ऑब्जेक्ट की संख्या बदलते ही इसका निश्चित आकार एक सीमा बन जाता है। Javaहै संग्रह ढांचा प्रदान करता है ArrayList गतिशील विकल्प के रूप में। नीचे दी गई तालिका दर्शाती है कि प्रत्येक विकल्प कब उपयुक्त है।

जब मेमोरी की सीमित खपत और अनुमानित इंडेक्सिंग मायने रखती हो, जैसे कि मैट्रिक्स लेआउट या प्रदर्शन-महत्वपूर्ण हॉट पाथ में, तो ऐरे का उपयोग करें। ArrayList अधिकांश रोजमर्रा के एप्लिकेशन कोड में, क्योंकि पुनः आवंटन के बिना जोड़ने और हटाने की क्षमता प्रति-तत्व मामूली ओवरहेड से कहीं अधिक महत्वपूर्ण है।

अक्सर पूछे जाने वाले प्रश्न