जावा में वस्तुओं की एक सरणी बनाना

Question

मैं जावा के लिए नया हूं और समय के लिए जावा में वस्तुओं की एक सरणी बनाई।

मेरे पास उदाहरण के लिए एक वर्ग ए है -

A[] arr = new A[4];

लेकिन यह केवल A4 ऑब्जेक्ट्स के लिए संकेत (संदर्भ) बना रहा है और नहीं। क्या ये सही है? मैं देखता हूं कि जब मैं बनाए गए ऑब्जेक्ट्स में फ़ंक्शंस / वेरिएबल्स एक्सेस करने की कोशिश करता हूं, तो मुझे एक नल पॉइंटर अपवाद मिलता है। ऐसा करने के लिए मेरे पास मौजूद वस्तुओं में हेरफेर / उपयोग करने में सक्षम होने के लिए:

A[] arr = new A[4];
for (int i = 0; i < 4; i++) {
    arr[i] = new A();
}

क्या यह सही है या मैं कुछ गलत कर रहा हूं? अगर यह सही है, तो यह बहुत ही अजीब है।

संपादित करें: मुझे यह अजीब लगता है क्योंकि C ++ में आप सिर्फ नया कहते हैं A[4]और यह चार ऑब्जेक्ट बनाता है।

Comments

मैं सिर्फ यह कहना चाहता था कि यह एक असाधारण सहायक प्रश्न था; यह पूछने के लिए धन्यवाद।

— पांड्योराम

Answer 1

यह सही है।

A[] a = new A[4];

... Aऐसा करने के समान 4 संदर्भ बनाता है :

A a1;
A a2;
A a3;
A a4;

अब आप इस तरह a1.someMethod()आवंटित किए बिना नहीं कर सकते a1:

a1 = new A();

इसी तरह, सरणी के साथ आपको यह करने की आवश्यकता है:

a[0] = new A();

... उपयोग करने से पहले।

Comments

इस जवाब ने मुझे भ्रम की एक पूरी गुच्छा बचा लिया, इसके अस्तित्व के लिए धन्यवाद।

— पांड्योर्म

मुझे यह भ्रम भी था, क्योंकि मैं C ++ पृष्ठभूमि से हूं इसलिए मैंने हमेशा यह माना कि जैसे C ++ जावा के newकीवर्ड में भी कंस्ट्रक्टर को कॉल किया जाता है और मैं मेमोरी को आवंटित करता है। मुझे लगता है कि जावा में newकेवल C ++ की तुलना में वास्तविक ऑब्जेक्ट नहीं संदर्भ बनाता है। उत्तर के लिए धन्यवाद।

— कृष्ण ओझा

@ कृष्ण_ओज़ा, यहाँ C ++ से कोई अंतर नहीं है। पहले newएक सरणी ऑब्जेक्ट बनाता है। ये गतिशील रूप से आवंटित ऑब्जेक्ट ("हीप") हैं। तो अनुरूप C ++ कोड होगा A **a = new A*[4]; for (int i = 0; i < 4; ++i) { a[i] = new A(); }।

— वास्वोलॉड गोलोवानोव

मुझे लगता है कि नया संदर्भ बनाता है, लेकिन सी ++ के रूप में सरणी के प्रत्येक तत्वों के लिए निर्माणकर्ता को इनिशियलाइज़ क्यों नहीं किया जाता है। यह मूर्खतापूर्ण हो सकता है, लेकिन मैं पूछना चाहता हूं, अगर हम ऐसा करते हैं, तो कोई भी समस्या होगी? @MeBigFatGuy

— जासेर

@ जासर - तत्वों के लिए आप किस निर्माता को कॉल करेंगे? क्या होगा यदि एकमात्र तत्व निर्माता तर्क का एक गुच्छा लेता है? आप उन वस्तुओं का निर्माण कैसे करेंगे?

— MeBigFatGuy 22

Answer 2

यह सही है। आप भी कर सकते हैं:

A[] a = new A[] { new A("args"), new A("other args"), .. };

इस सिंटैक्स का उपयोग कहीं भी एक सरणी बनाने और शुरू करने के लिए किया जा सकता है, जैसे कि विधि तर्क में:

someMethod( new A[] { new A("args"), new A("other args"), . . } )

Answer 3

हां, यह केवल संदर्भ बनाता है, जो उनके डिफ़ॉल्ट मान शून्य पर सेट होते हैं। यही कारण है कि आपको एक NullPointerException मिलती है। आपको अलग से ऑब्जेक्ट बनाने और संदर्भ असाइन करने की आवश्यकता होती है। जावा में सरणियाँ बनाने के लिए 3 चरण हैं -

घोषणा - इस चरण में, हम डेटा प्रकार और उस सरणी के आयामों को निर्दिष्ट करते हैं जो हम बनाने जा रहे हैं। लेकिन याद रखें, हम अभी तक आयामों के आकार का उल्लेख नहीं करते हैं। उन्हें खाली छोड़ दिया जाता है।

तत्काल - इस चरण में, हम सरणी बनाते हैं, या नए कीवर्ड का उपयोग करके सरणी के लिए मेमोरी आवंटित करते हैं। यह इस चरण में है कि हम सरणी आयामों के आकारों का उल्लेख करते हैं।

इनिशियलाइज़ेशन - सरणी हमेशा डेटा प्रकार के डिफ़ॉल्ट मान के लिए आरंभिक होती है। लेकिन हम अपनी शुरुआत खुद कर सकते हैं।

जावा में ऐरे की घोषणा

इस तरह हम जावा में एक आयामी आयाम की घोषणा करते हैं -

int[] array;
int array[];

Oracle अनुशंसा करता है कि आप सरणियों को घोषित करने के लिए पूर्व सिंटैक्स का उपयोग करें। यहाँ कानूनी घोषणाओं के कुछ अन्य उदाहरण हैं -

// One Dimensional Arrays
int[] intArray;             // Good
double[] doubleArray;

// One Dimensional Arrays
byte byteArray[];           // Ugly!
long longArray[];

// Two Dimensional Arrays
int[][] int2DArray;         // Good
double[][] double2DArray;

// Two Dimensional Arrays
byte[] byte2DArray[];       // Ugly
long[] long2DArray[];

और ये अवैध घोषणाओं के कुछ उदाहरण हैं -

int[5] intArray;       // Don't mention size!
double{} doubleArray;  // Square Brackets please!

प्रारंभ

इस प्रकार हम एक सरणी के लिए "तत्काल" या स्मृति आवंटित करते हैं -

int[] array = new int[5];

जब JVM newकीवर्ड का सामना करता है , तो यह समझता है कि उसे किसी चीज़ के लिए मेमोरी आवंटित करनी चाहिए। और निर्दिष्ट करके int[5], हमारा मतलब है कि हम intआकार की एक सरणी चाहते हैं । 5।int[]

प्रारंभ

लूप का उपयोग करना - किसी ऐरे के तत्वों को इनिशियलाइज़ करने के लिए लूप के लिए उपयोग करना ऐरे को प्राप्त करने का सबसे आम तरीका है। यदि आप डिफ़ॉल्ट मान को असाइन करने जा रहे हैं, तो लूप के लिए चलाने की कोई आवश्यकता नहीं है, क्योंकि JVM आपके लिए ऐसा करता है।

ऑल - इन - वन..! - हम अपने ऐरे को डिक्लेयर, इंस्टेंट और इनिशियलाइज़ कर सकते हैं। यहाँ वाक्य रचना है -

int[] arr = {1, 2, 3, 4, 5};

यहाँ, हम आकार का उल्लेख नहीं करते हैं, क्योंकि JVM देख सकता है कि हम 5 मान दे रहे हैं।

इसलिए, जब तक हम संदर्भों को तत्काल शून्य नहीं कर देते हैं। मुझे उम्मीद है कि मेरे जवाब ने आपकी मदद की है ..! :)

स्रोत - जावा में ऐरे

Answer 4

पैरामीटर लेने वाले एक कंस्ट्रक्टर के साथ 10 कर्मचारी ऑब्जेक्ट्स की सरणी बनाने का स्पष्ट उदाहरण यहां दिया गया है:

public class MainClass
{  
    public static void main(String args[])
    {
        System.out.println("Hello, World!");
        //step1 : first create array of 10 elements that holds object addresses.
        Emp[] employees = new Emp[10];
        //step2 : now create objects in a loop.
        for(int i=0; i<employees.length; i++){
            employees[i] = new Emp(i+1);//this will call constructor.
        }
    }
}

class Emp{
    int eno;
    public Emp(int no){
        eno = no;
        System.out.println("emp constructor called..eno is.."+eno);
    }
}

Answer 5

तुम सही हो। इसके अलावा अगर हम जावा "8 (जो स्ट्रीम एपीआई का परिचय देते हैं) के बाद से हम कुछ" कारखाने "द्वारा प्रदान किए गए तत्वों से भरे विशिष्ट आकार की सरणी बनाना चाहते हैं, तो हम इस एक-लाइनर का उपयोग कर सकते हैं:

A[] a = Stream.generate(() -> new A()).limit(4).toArray(A[]::new);

• Stream.generate(() -> new A())अलग-अलग ए तत्वों के लिए कारखाने की तरह है, () -> new A()जिसे लाम्बा द्वारा वर्णित किया गया है, जिसका कार्यान्वयन है Supplier<A>- यह वर्णन करता है कि प्रत्येक नए ए उदाहरण कैसे बनाए जाने चाहिए।
• limit(4)तत्वों की मात्रा निर्धारित करता है जो स्ट्रीम उत्पन्न करेगा
• toArray(A[]::new)(के रूप में भी फिर से लिखा जा सकता है toArray(size -> new A[size])) - यह हमें सरणी के प्रकार का निर्णय / वर्णन करने देता है जिसे वापस लौटाया जाना चाहिए।

कुछ आदिम प्रकार आप उपयोग कर सकते हैं DoubleStream, IntStream, LongStreamजो अतिरिक्त की तरह जनरेटर उपलब्ध कराने range rangeClosedऔर कुछ अन्य।

Answer 6

हां यह सही है जावा में वस्तुओं की एक सरणी बनाने के लिए कई चरण हैं:

1. घोषणा करना और फिर झटपट बनाना ('4' ऑब्जेक्ट को स्टोर करने के लिए मेमोरी बनाएं):

   A[ ] arr = new A[4];

2. ऑब्जेक्ट्स को इनिशियलाइज़ करना (इस मामले में आप क्लास ए की 4 ऑब्जेक्ट्स को इनिशियलाइज़ कर सकते हैं)

   arr[0] = new A();
   arr[1] = new A();
   arr[2] = new A();
   arr[3] = new A();

   या

   for( int i=0; i<4; i++ )
     arr[i] = new A();

अब आप अपने द्वारा बनाई गई वस्तुओं आदि से मौजूदा तरीकों को कॉल करना शुरू कर सकते हैं।

उदाहरण के लिए:

  int x = arr[1].getNumber();

या

  arr[1].setNumber(x);

Answer 7

जेनेरिक क्लास के लिए रैपर क्लास बनाना आवश्यक है। उदाहरण के लिए:

Set<String>[] sets = new HashSet<>[10]

में परिणाम: "एक सामान्य सरणी नहीं बना सकते"

इसके बजाय उपयोग करें:

        class SetOfS{public Set<String> set = new HashSet<>();}
        SetOfS[] sets = new SetOfS[10];  

Comments

क्या इस पंक्ति का मतलब है, आप सेट की एक सरणी बनाने की कोशिश कर रहे हैं, जहां सेट प्रकार स्ट्रिंग है?

— sofs1

Answer 8

जावा में एक नई सारणी घोषित करने के लिए इस प्रकार है:

type arrayName[] = new type[numberOfElements];

जहाँ प्रकार एक आदिम प्रकार या वस्तु है। numberOfElementsउन तत्वों की संख्या है जिन्हें आप सरणी में संग्रहीत करेंगे और यह मान बदल नहीं सकता है क्योंकि जावा डायनेमिक सरणियों का समर्थन नहीं करता है (यदि आपको ऑब्जेक्ट को रखने के लिए एक लचीली और गतिशील संरचना की आवश्यकता है तो आप कुछ जावा संग्रह का उपयोग करना चाह सकते हैं)।

5 लोगों की एक छोटी कंपनी में सभी कर्मचारियों के वेतन को स्टोर करने के लिए एक सरणी शुरू करते हैं:

int salaries[] = new int[5];

सरणी का प्रकार (इस मामले में int) सरणी में सभी मानों पर लागू होता है। आप एक सरणी में प्रकार नहीं मिला सकते हैं।

अब जब हमारे पास हमारी सैलरी सरणी है तो हम इसे कुछ मूल्यों में रखना चाहते हैं। हम इसे आरंभीकरण के दौरान इस तरह से कर सकते हैं:

int salaries[] = {50000, 75340, 110500, 98270, 39400};

या बाद में इस तरह से करना है:

salaries[0] = 50000;
salaries[1] = 75340;
salaries[2] = 110500;
salaries[3] = 98270;
salaries[4] = 39400;

सरणी निर्माण का अधिक दृश्य उदाहरण:

Arrays के बारे में अधिक जानने के लिए, मार्गदर्शिका देखें ।