इंट संख्या =( (1,2), (1,2), (1,2), (1,2), (1,2) );

रॅग्ड ॲरे (किंवा नॉन-आयताकृती ॲरे)

int num = नवीन int;

संख्या = नवीन इंट;

संख्या = नवीन इंट;

संख्या = नवीन इंट;

संख्या = नवीन इंट;

म्हणून येथे आम्ही स्तंभ स्पष्टपणे परिभाषित करतो.

दुसरा मार्ग:

इंट संख्या =( (1), (1,2), (1,2,3,4,5), (1,2), (1,2,3) );

प्रवेश करण्यासाठी:

साठी (int i=0; i

ही ॲरे घोषणा नाही, परंतु खालील विधान खालील अभिव्यक्ती पूर्ण करते:

MyIntArray=new int;

तुम्ही प्रत्येक भाग समजून घेतल्यास मला ते उपयुक्त वाटते:

प्रकार नाव = नवीन प्रकार;

प्रकार हा नाव नावाच्या व्हेरिएबलचा प्रकार आहे ("नाव" ला ओळखकर्ता म्हणतात). शाब्दिक "प्रकार" हा बेस प्रकार आहे आणि कंस म्हणजे तो त्या बेसचा ॲरे प्रकार आहे. ॲरे प्रकार, त्या बदल्यात, त्यांचे स्वतःचे असतात, जे तुम्हाला प्रकार प्रकाराचे बहुआयामी ॲरे तयार करण्यास अनुमती देतात ( ॲरे प्रकार प्रकार ). नवीन कीवर्ड नवीन ॲरेसाठी मेमरीच्या वाटपाचा संदर्भ देतो. ब्रॅकेटमधील संख्या नवीन ॲरे किती मोठी असेल आणि किती मेमरी वाटप केली जाईल हे सांगते. उदाहरणार्थ, जर Java जाणते की अंतर्निहित प्रकार 32 बाइट्स आहे, आणि तुम्हाला आकार 5 चा ॲरे हवा असेल, तर त्याला अंतर्गत 32 * 5 = 160 बाइट्स वाटप करणे आवश्यक आहे.

तुम्ही आधीच अस्तित्वात असलेल्या मूल्यांसह ॲरे देखील तयार करू शकता, जसे की

इंट नेम = (1, 2, 3, 4, 5);

जे केवळ रिक्त जागाच निर्माण करत नाही तर या मूल्यांनी भरते. Java सांगू शकते की आदिम पूर्णांक आहेत आणि त्यापैकी 5 आहेत, त्यामुळे ॲरेचा आकार स्पष्टपणे निर्धारित केला जाऊ शकतो.

तसेच, जर तुम्हाला काहीतरी अधिक डायनॅमिक हवे असेल तर, सूची इंटरफेस आहे. हे कार्य करणार नाही, परंतु अधिक लवचिक आहे:

यादी listOfString = नवीन ArrayList (); listOfString.add("foo"); listOfString.add("bar"); स्ट्रिंग मूल्य = listOfString.get(0); assertEquals(मूल्य, "foo");

ॲरे तयार करण्याचे दोन मुख्य मार्ग आहेत:

हे, रिक्त ॲरेसाठी:

इंट ॲरे = नवीन इंट[n]; // "n" म्हणजे ॲरेमध्ये वाटप करण्यासाठी स्पेसची संख्या

आणि हे, आरंभ केलेल्या ॲरेसाठी:

इंट ॲरे = (1,2,3,4 ...);

तुम्ही बहुआयामी ॲरे देखील तयार करू शकता, उदाहरणार्थ:

Int array2d = नवीन int[x][y]; // "x" आणि "y" int array2d = ( (1,2,3 ...), (4,5,6 ...) ...) परिमाण निर्दिष्ट करतात;

उदाहरणार्थ int हा आदिम प्रकार घ्या. इंट ॲरे घोषित करण्याचे अनेक मार्ग आहेत:

इंट मी = नवीन इंट; int i = नवीन int (value1, value2, value3, etc); int i = (value1, value2, value3, etc);

या सर्व प्रकरणांमध्ये तुम्ही int i ऐवजी int i वापरू शकता.

प्रतिबिंबासह तुम्ही (Type) Array.newInstance(Type.class, क्षमता) वापरू शकता;

लक्षात घ्या की मेथड पॅरामीटर्स... व्हेरिएबल आर्ग्युमेंट्स प्रदर्शित करतात. मूलभूतपणे, कितीही पॅरामीटर्स ठीक आहेत. कोडसह स्पष्ट करणे सोपे आहे:

सार्वजनिक स्थिर शून्य varargs(int fixed1, String fixed2, int... varargs) (...) ... varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = (100) varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = (100, 200);

पद्धतीच्या आत, varargs सामान्य int प्रमाणे मानले जाते. Type... फक्त मेथड पॅरामीटर्समध्ये वापरला जाऊ शकतो, त्यामुळे int... i = new int() संकलित होणार नाही.

लक्षात ठेवा की मेथड (किंवा इतर कोणत्याही प्रकार) मध्ये int पास करताना, तुम्ही तिसरा मार्ग वापरू शकत नाही. int i = *(a, b, c, d, etc)* विधानामध्ये, कंपाइलर गृहीत धरतो की (...) म्हणजे int. पण कारण तुम्ही व्हेरिएबल घोषित करत आहात. पद्धतीमध्ये ॲरे पास करताना, घोषणा एकतर नवीन प्रकार किंवा नवीन प्रकार (...) असणे आवश्यक आहे.

बहुआयामी ॲरे

बहुआयामी ॲरे हाताळणे अधिक कठीण आहे. मूलत:, 2D ॲरे हा ॲरेचा ॲरे आहे. int म्हणजे int s चा ॲरे. मुख्य म्हणजे int ला int[x][y] म्हणून घोषित केले असल्यास, कमाल निर्देशांक i आहे. मूलत:, एक आयत इंट समान आहे:

ऑब्जेक्ट संदर्भांची ॲरे घोषित करणे:

वर्ग प्राणी () वर्ग घोडा प्राणी ( सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग आर्ग्स) (/* * ॲरे ऑफ ॲनिमल ॲनिमल आणि हॉर्स धारण करू शकतो (प्राण्यांचे सर्व उपप्रकार अनुमत) */ प्राणी a1 = नवीन प्राणी; a1 = नवीन प्राणी() ; a1 = नवीन घोडा (); /* * ॲरे ऑफ ॲनिमल आणि सर्व उपप्रकार घोडा */ प्राणी a2 = नवीन प्राणी(); प्राण्यांचा उपप्रकार */ H1 = नवीन Horse;

ॲरे ही घटकांची अनुक्रमिक सूची आहे

इंट आयटम = मूल्य; int one_dimensional_array = (मूल्य, मूल्य, मूल्य, .., मूल्य); int two_dimensional_array = ( ( मूल्य, मूल्य, मूल्य, .. मूल्य ), ( मूल्य, मूल्य, मूल्य, .. मूल्य ), .. .. .. .. (मूल्य, मूल्य, मूल्य, .. मूल्य));

जर ही वस्तू असेल तर हीच संकल्पना आहे

ऑब्जेक्ट आयटम = नवीन ऑब्जेक्ट (); ऑब्जेक्ट one_dimensional_array = ( नवीन ऑब्जेक्ट(), नवीन ऑब्जेक्ट(), .. नवीन ऑब्जेक्ट() ); ऑब्जेक्ट द्वि-आयामी_ॲरे = ( ( नवीन ऑब्जेक्ट(), नवीन ऑब्जेक्ट(), .. नवीन ऑब्जेक्ट() ), ( नवीन ऑब्जेक्ट(), नवीन ऑब्जेक्ट(), .. नवीन ऑब्जेक्ट() ), .. .. .. ( नवीन ऑब्जेक्ट(), नवीन ऑब्जेक्ट(), .. नवीन ऑब्जेक्ट() ) );

ऑब्जेक्ट्सच्या बाबतीत तुम्हाला नवीन प्रकार(..) वापरून इनिशिएलायझेशनसाठी null वर नियुक्त करणे आवश्यक आहे, String आणि Integer सारखे वर्ग हे विशेष प्रकरण आहेत ज्यांना खालीलप्रमाणे मानले जाईल.

स्ट्रिंग a = ("हॅलो", "वर्ल्ड"); // स्ट्रिंग a = ( नवीन स्ट्रिंग(("h","e","l","l","o")), नवीन स्ट्रिंग(("w","o","r" च्या समतुल्य आहे ,"l","d"))); पूर्णांक b = ( 1234, 5678); // पूर्णांक b = ( नवीन पूर्णांक(1234), नवीन पूर्णांक(5678) );

सर्वसाधारणपणे तुम्ही एम डायमेंशनल असलेले ॲरे तयार करू शकता

इंट .. ॲरे = // ^ एम वेळा कंस (..( // ^ एम वेळा ( कंस // हा ॲरे आहे.. // ^ एम वेळा ))..) // ^ एम वेळा ) कंस ;

हे लक्षात घेण्यासारखे आहे की मितीय ॲरे एम तयार करणे स्पेसच्या दृष्टीने महाग आहे. कारण जेव्हा तुम्ही सर्व परिमाणांमध्ये N सह M एक ॲरे तयार करता तेव्हा ॲरेचा एकूण आकार N^M पेक्षा मोठा असतो, कारण प्रत्येक ॲरेला लिंक असते आणि M डायमेंशनमध्ये (M -1)-आयामी ॲरे असते दुव्यांचे. एकूण आकार खालीलप्रमाणे आहे

ॲरे(ॲरे) _ हे समान प्रकारच्या घटकांचे क्रमबद्ध संच आहेत. ॲरेचे घटक साध्या आणि संदर्भ प्रकारच्या वस्तू असू शकतात, ज्यामध्ये संख्या आणि इतर ॲरेचे संदर्भ समाविष्ट आहेत. ॲरे स्वतःच वस्तू आहेत आणि

ऑब्जेक्ट क्लास इनहेरिट करा. घोषणा

int ia = नवीन int;

ia नावाचा ॲरे परिभाषित करतो जो सुरुवातीला int प्रकारातील तीन घटकांच्या संचाकडे निर्देश करतो.

ॲरे घोषणा त्याचे परिमाण दर्शवत नाही. नवीन ऑपरेटर वापरून तयार केल्यावर ॲरे घटकांची संख्या निर्दिष्ट केली जाते. ॲरेची लांबी निर्मितीच्या वेळी निश्चित केली जाते आणि नंतर बदलली जाऊ शकत नाही. तथापि, चलॲरे प्रकार (आमच्या उदाहरणामध्ये – ia) वेगळ्या आकारमानासह नवीन ॲरे कधीही नियुक्त केला जाऊ शकतो.

ॲरे घटकांना त्यांच्या इंडेक्स क्रमांकांच्या मूल्यांद्वारे प्रवेश केला जातो.

पहिल्या ॲरे घटकाची अनुक्रमणिका शून्य (0) आहे आणि शेवटची लांबी 1 आहे. ॲरेचे नाव आणि अनुक्रमणिका मूल्य निर्दिष्ट करून ॲरे घटकामध्ये प्रवेश केला जातो, जो चौरस कंसात बंद केला जातो, [ आणि ]. मागील उदाहरणामध्ये, ia ॲरेचा पहिला घटक ia असेल आणि शेवटचा घटक ia असेल. जेव्हा जेव्हा ॲरे घटक इंडेक्सद्वारे ऍक्सेस केला जातो, तेव्हा Java रनटाइम इंडेक्स मूल्य स्वीकार्य मर्यादेत आहे की नाही हे तपासते आणि चेक रिझल्ट चुकीचा असल्यास ArraylndexOutOfBoundsException प्रकाराचा अपवाद टाकतो. 6 निर्देशांक अभिव्यक्ती int प्रकारची असणे आवश्यक आहे - ही एकमेव गोष्ट आहे जी ॲरे घटकांची कमाल संख्या मर्यादित करते.

ॲरे ऑब्जेक्टची लांबी फील्ड वापरून ॲरेची लांबी सहजपणे निर्धारित केली जाऊ शकते (जे सार्वजनिक आणि अंतिम गुणधर्मांसह स्पष्टपणे प्रदान केले जाते). खाली मागील उदाहरणाचा अद्ययावत कोड आहे, जो लूपच्या अंमलबजावणीसाठी प्रदान करतो जो ॲरे ia च्या प्रत्येक घटकाची सामग्री स्क्रीनवर प्रदर्शित केली जाईल याची खात्री करतो:

साठी (int i = o; i< ia.length; i++)

system.out.println(i + ": " + ia[i]);

शून्य लांबीच्या ॲरेला (म्हणजे कोणतेही घटक नसलेले) म्हणतात रिक्तलक्षात घ्या की शून्य ॲरे संदर्भ आणि रिक्त ॲरे संदर्भ या दोन पूर्णपणे भिन्न गोष्टी आहेत. रिक्त ॲरे एक वास्तविक ॲरे आहे ज्यामध्ये कोणतेही घटक नसतात. मेथडमधून परत येताना रिक्त ॲरे शून्यासाठी सोयीस्कर पर्याय प्रदान करते. जर एखादी पद्धत शून्य रिटर्न करण्यास सक्षम असेल, तर मेथडला कॉल करणाऱ्या ऍप्लिकेशन कोडने उर्वरित ऑपरेशन्ससह पुढे जाण्यापूर्वी रिटर्न केलेल्या मूल्याची शून्यशी तुलना करणे आवश्यक आहे. जर पद्धत ॲरे (शक्यतो रिकामी) परत करत असेल, तर कोणत्याही अतिरिक्त तपासण्यांची आवश्यकता नाही - अर्थातच, ॲरेच्या लांबीशी संबंधित असलेल्या व्यतिरिक्त, जे कोणत्याही परिस्थितीत केले पाहिजे.

ॲरे डिक्लेरेशनचा दुसरा प्रकार देखील अनुमत आहे, ज्यामध्ये स्क्वेअर ब्रॅकेट ॲरे आयडेंटिफायर नंतर निर्दिष्ट केले जातात, आणि त्याच्या प्रकाराच्या नावानंतर नाही:

int ia = नवीन int;

पूर्वीचे वाक्यरचना, तथापि, श्रेयस्कर मानले जाते कारण ते प्रकार घोषणा अधिक संक्षिप्त करते.

ॲरे घोषणांमध्ये सुधारक

घोषणांमध्ये विशिष्ट ॲरे वापरण्याचे नियम सुधारकसामान्य आहेत आणि केवळ ॲरे कोणत्या श्रेणीशी संबंधित आहे यावर अवलंबून असतात - फील्ड किंवा स्थानिक चल. लक्षात ठेवणे महत्त्वाचे आहे की एक गोष्ट आहे - सुधारक ॲरेवरच लागू होतात, परंतु त्याच्या वैयक्तिक घटकांवर लागू होत नाहीत. जर अंतिम विशेषता ॲरे घोषणेमध्ये निर्दिष्ट केली असेल, तर याचा अर्थ केवळ ॲरेचा संदर्भ त्याच्या निर्मितीनंतर बदलला जाऊ शकत नाही, परंतु कोणत्याही प्रकारे ॲरेच्या वैयक्तिक घटकांची सामग्री बदलण्याची क्षमता प्रतिबंधित करत नाही. भाषा तुम्हाला ॲरे घटकांसाठी कोणतेही मॉडिफायर (म्हणा, अंतिम किंवा अंतिम) निर्दिष्ट करण्याची परवानगी देत ​​नाही.

बहुआयामी ॲरे

Java घोषित करण्याच्या क्षमतेस समर्थन देते बहुआयामी ॲरे(बहु-आयामी ॲरे) (म्हणजे ॲरे ज्यांचे घटक इतर ॲरे आहेत), कोड ज्यामध्ये द्विमितीय मॅट्रिक्स घोषित करणे आणि त्यातील घटकांची सामग्री स्क्रीनवर प्रदर्शित करणे समाविष्ट आहे, उदाहरणार्थ, यासारखे:

float mat = नवीन फ्लोट;

सेटअप मॅट्रिक्स(चटई);

साठी (int y = o; y< mat.length; у++) {

साठी (int x = o; x< mat[y].length; х++)

system.out.print(mat[y][x] + "");

system.out.println();

ॲरे तयार करताना, किमान त्याचे पहिले, "सर्वात डावीकडे" परिमाण निर्दिष्ट करणे आवश्यक आहे. इतर परिमाणे निर्दिष्ट केले जाऊ शकत नाहीत - या प्रकरणात ते नंतर निर्धारित करावे लागतील. नवीन ऑपरेटरमध्ये एकाच वेळी सर्व परिमाणे निर्दिष्ट करणे हा ॲरे तयार करण्याचा सर्वात संक्षिप्त मार्ग आहे, ज्यामुळे तुम्हाला अतिरिक्त नवीन ऑपरेटर वापरण्याची आवश्यकता टाळता येईल. वरील मॅट ॲरे घोषित करण्यासाठी आणि तयार करण्यासाठी अभिव्यक्ती खालील कोड स्निपेटच्या समतुल्य आहे:

float mat = नवीन फ्लोट;

साठी (int y = o; y< mat.length; у++)

mat[y] = नवीन फ्लोट;

घोषणेच्या या स्वरूपाचा फायदा आहे की, समान परिमाणे (म्हणजे, 4 x 4) सह ॲरे मिळवण्याबरोबरच, हे तुम्हाला विशिष्ट डेटा अनुक्रम संचयित करण्यासाठी आवश्यक असलेल्या विविध आयामांच्या ॲरे तयार करण्यास अनुमती देते.

ॲरे सुरू करत आहे

ॲरे तयार केल्यावर, ॲरे प्रकारानुसार प्रत्येक घटकाला डीफॉल्ट मूल्य प्राप्त होते: अंकीय प्रकारांसाठी शून्य (0), चारसाठी '\u0000′_, बुलियनसाठी असत्य आणि संदर्भ प्रकारांसाठी शून्य. संदर्भ प्रकाराचा ॲरे घोषित करून, आम्ही प्रत्यक्षात ॲरे परिभाषित करत आहोत तात्पुरतेहा प्रकार. खालील कोड स्निपेट विचारात घ्या:

Attr attrs = new Attr;

साठी (int i = o; i< attrs.length; i++)

attrs[i] = नवीन Attr(नावे[i], मूल्ये[i]);

नवीन ऑपरेटर असलेली पहिली अभिव्यक्ती कार्यान्वित केल्यानंतर, attrs व्हेरिएबलमध्ये 12 व्हेरिएबल्सचा संदर्भ असेल जो लूपमध्ये सुरू होईल तेव्हाच Attr ऑब्जेक्ट्स तयार होतील.

कर्ली ब्रेसेसमधील रचना वापरून ॲरे आरंभ केला जाऊ शकतो (त्याच्या घोषणेप्रमाणेच) त्याच्या घटकांची प्रारंभिक मूल्ये सूचीबद्ध करतो:

स्ट्रिंग धोके = ("सिंह", "वाघ", "अस्वल");

खालील कोड स्निपेट समान परिणाम देईल:

स्ट्रिंग धोके = नवीन स्ट्रिंग; धोके = "सिंह";

धोका = "वाघ";

धोका = "अस्वल";

पहिला फॉर्म, जो कर्ली ब्रेसेसमध्ये इनिशिएलायझर्सची सूची प्रदान करतो, नवीन ऑपरेटरच्या स्पष्ट वापराची आवश्यकता नाही - याला रनटाइम सिस्टमद्वारे अप्रत्यक्षपणे म्हटले जाते. या प्रकरणात ॲरेची लांबी इनिशिएलायझर व्हॅल्यूच्या संख्येद्वारे निर्धारित केली जाते. नवीन ऑपरेटर स्पष्टपणे निर्दिष्ट करणे देखील शक्य आहे, परंतु परिमाण अद्याप पूर्वीप्रमाणेच वगळले पाहिजे, ते अंमलबजावणी प्रणालीद्वारे निर्धारित केले जाते:

स्ट्रिंग धोके = नवीन स्ट्रिंग ("सिंह", "वाघ", "अस्वल");

ॲरेची घोषणा आणि इनिशिएलायझेशनचा हा प्रकार कोडमध्ये कुठेही वापरला जाऊ शकतो, उदाहरणार्थ मेथड कॉल एक्सप्रेशनमध्ये:

printStringsCnew स्ट्रिंग ("एक", "दोन", "तीन" ));

अशा प्रकारे तयार केलेल्या शीर्षक नसलेल्या ॲरेला म्हणतात निनावी(निनावी).

ॲरेचे ॲरे प्रारंभिक मूल्यांच्या नेस्टेड अनुक्रमांद्वारे आरंभ केले जाऊ शकतात. खाली तथाकथित पहिल्या काही पंक्ती असलेल्या ॲरे घोषित करण्याचे उदाहरण आहे पास्कलचा त्रिकोणजेथे प्रत्येक पंक्तीचे स्वतःच्या मूल्यांच्या ॲरेद्वारे वर्णन केले जाते.

int pascalsTrangle = (

{ 1, 4, 6, 4, 1 },

बहुआयामी ॲरेचे निर्देशांक बाह्य ते आतील क्रमाने असतात. तर, उदाहरणार्थ, pascalsTrangle हे ॲरेमधील i-th पूर्णांकाच्या बरोबरीचे आहे.

खालीलप्रमाणे ॲरे घोषित केला जातो: प्रथम, ॲरेचा प्रकार दर्शविला जातो, म्हणजेच ॲरेमध्ये समाविष्ट असलेल्या घटकांचा प्रकार, त्यानंतर रिक्त चौरस कंसांची जोडी आणि नंतर व्हेरिएबलचे नाव. उदाहरणार्थ, पूर्णांक असलेली ॲरे कशी घोषित करायची ते येथे आहे:
int a;

तथापि, हे विधान प्रत्यक्ष ॲरेसह प्रारंभ न करता केवळ व्हेरिएबल a घोषित करते. ॲरे तयार करण्यासाठी, तुम्हाला नवीन ऑपरेटर वापरण्याची आवश्यकता आहे.

हा ऑपरेटर 100 पूर्णांकांचा ॲरे तयार करतो. या ॲरेचे घटक 0 ते 99 पर्यंत क्रमांकित आहेत (1 ते 100 पर्यंत नाही). एकदा तयार केल्यावर, ॲरे भरता येते, उदाहरणार्थ, लूप वापरून.

int a = नवीन int;
साठी (int i = 0; i< 100; i++)
a[i] = i; // 0 ते 99 पर्यंतच्या संख्येसह ॲरे भरते.

100 घटकांचा ॲरे तयार करून तुम्ही घटक a (किंवा इतर कोणताही घटक ज्याचा अनुक्रमणिका 0 ते 99 श्रेणीच्या बाहेर आहे) प्रवेश करण्याचा प्रयत्न केला, तर प्रोग्राम संपुष्टात येईल कारण सीमारेषेच्या बाहेर ॲरे इंडेक्स येईल.
ॲरेमधील घटकांची संख्या मोजण्यासाठी, nameMass पद्धत वापरा.
va. लांबी.

उदाहरणार्थ,

साठी (int i = 0; i< a. length; i++ System.out.println (a[i]);

एकदा ॲरे तयार झाल्यानंतर, त्याचा आकार बदलणे अशक्य आहे (जरी आपण, अर्थातच, त्याचे वैयक्तिक घटक बदलू शकता). प्रोग्रामच्या अंमलबजावणीदरम्यान तुम्हाला ॲरेचा आकार वारंवार बदलण्याची आवश्यकता असल्यास, ॲरे सूची नावाची दुसरी डेटा रचना वापरणे चांगले.

ॲरे दोन प्रकारे घोषित केले जाऊ शकते:

int a;
किंवा
int a;

बहुतेक जावा प्रोग्रामर प्रथम शैलीला प्राधान्य देतात कारण ते व्हेरिएबल नावापासून इंट ॲरे प्रकार अधिक स्पष्टपणे वेगळे करते.

ॲरे इनिशिएलायझर्स आणि अनामित ॲरे

Java मध्ये एकाच वेळी ॲरे तयार करण्याची आणि ती सुरू करण्याची सुविधा आहे. अशा सिंटॅक्टिक स्ट्रक्चरचे एक उदाहरण येथे आहे:

int smallPrimes = ( 2, 3, 5, 7, 11, 13);

लक्षात घ्या की या प्रकरणात नवीन ऑपरेटर वापरण्याची आवश्यकता नाही. याव्यतिरिक्त, तुम्ही अनामित ॲरे देखील सुरू करू शकता:

नवीन इंट (16, 19, 23, 29, 31, 37)

हे अभिव्यक्ती नवीन ॲरेसाठी मेमरी वाटप करते आणि कर्ली ब्रेसेसमध्ये निर्दिष्ट केलेल्या संख्येसह ते भरते. या प्रकरणात, त्यांची संख्या मोजली जाते आणि त्यानुसार, ॲरेचा आकार निर्धारित केला जातो. हे सिंटॅक्टिक कन्स्ट्रक्शन नवीन व्हेरिएबल तयार न करता ॲरे पुन्हा सुरू करण्यासाठी वापरण्यास सोयीचे आहे. उदाहरणार्थ, अभिव्यक्ती

स्मॉल प्राइम्स = नवीन इंट (17, 19, 23, 29, 31, 37);
एक संक्षिप्त अभिव्यक्ती आहे
int अनामित = ( 17, 19, 23, 29, 31, 37);
smailPrimes = अनामित;

तुम्ही शून्य आकाराची ॲरे तयार करू शकता. अशा प्रकारचा ॲरे रिकामे असल्याचे मूल्यांकन करणारी पद्धत लिहिताना उपयुक्त ठरू शकते. शून्य-लांबीचा ॲरे खालीलप्रमाणे घोषित केला आहे:

नवीन घटक प्रकार

लक्षात घ्या की असा ॲरे शून्य ऑब्जेक्टच्या समतुल्य नाही.

ॲरे कॉपी करत आहे

एक ॲरे दुसऱ्यावर कॉपी केला जाऊ शकतो, परंतु दोन्ही व्हेरिएबल्स एकाच ॲरेचा संदर्भ घेतील.

int luckyNumbers = smailPrimes;
luckyNimbers = 12; // आता smailPrimes घटक देखील 12 आहे.

परिणाम अंजीर मध्ये दर्शविले आहे. ३.१४. तुम्हाला एका ॲरेचे सर्व घटक दुसऱ्यामध्ये कॉपी करायचे असल्यास, तुम्ही सिस्टम क्लासमधील ॲरेकॉपी पद्धत वापरावी. त्याचा कॉल यासारखा दिसतो:

System.arraycopy(पासून, fromlndex, to, tolndex, count);

टू ॲरे कॉपी करण्यासाठी सर्व घटक समाविष्ट करण्यासाठी पुरेसे मोठे असणे आवश्यक आहे.

तांदूळ. ३.१४. ॲरे कॉपी करत आहे

उदाहरणार्थ, खाली दर्शविलेले ऑपरेटर, ज्याचे परिणाम अंजीर मध्ये दर्शविले आहेत. 3.15, दोन ॲरे तयार करा आणि नंतर पहिल्या ॲरेचे शेवटचे चार घटक दुसऱ्यामध्ये कॉपी करा. कॉपी करणे स्त्रोत ॲरेमधील दुसऱ्या स्थानापासून सुरू होते आणि कॉपी केलेले घटक तिसऱ्या स्थानापासून सुरू होणाऱ्या गंतव्य ॲरेमध्ये ठेवले जातात.

int smailPrimes = (2, 3, 5, 7, 11, 13);
int luckyNumbers = (1001, 1002, 1003, 1004, 1005, 1006, 1007);
System.aggausor(smailPrimes, 2, luckyNumbers, 3, 4);
साठी (int i = 0; i< luckyNumbers.length; i++)
System.println(i +.": " + luckyNumbersfi]);

ही विधाने अंमलात आणल्याने पुढील परिणाम मिळतात.

0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13

तांदूळ. ३.१५. ॲरे घटक कॉपी करत आहे

Java मधील ॲरे C++ मधील ॲरेपेक्षा लक्षणीयरीत्या भिन्न आहे. तथापि, ते डायनॅमिक ॲरेच्या पॉइंटरसारखेच आहे. याचा अर्थ ऑपरेटर

int a = नवीन int; //जावा
ऑपरेटरच्या समतुल्य आहे
i n t * = नवीन i n t [ 1 0 0 ] ; // C++,
आणि नाही
int a; // C++

Java मध्ये, डीफॉल्ट नो ऑपरेटर अनुक्रमणिकेची श्रेणी तपासत नाही. याव्यतिरिक्त, Java मध्ये पॉइंटर अंकगणित नाही- तुम्ही ॲरेच्या पुढील घटकामध्ये प्रवेश करण्यासाठी पॉइंटर वाढवू शकत नाही.

• ट्यूटोरियल

मला असे वाटते की त्यांच्या पहिल्या मुलाखतीची तयारी करणाऱ्यांपैकी काही, (पूर्व) कनिष्ठ प्रोग्रामर म्हणून त्यांच्या पहिल्या नोकरीसाठी अर्ज करताना, या प्रश्नाचे उत्तर नकारार्थी देतील. किंवा किमान सकारात्मक उत्तराबद्दल शंका घ्या. अर्थात, थेट निर्देशांक प्रवेशासह अशी साधी डेटा रचना - कोणत्याही युक्त्या नाहीत! नाही, JavaScript किंवा PHP सारख्या काही भाषांमध्ये, ॲरे अर्थातच अतिशय मनोरंजक पद्धतीने अंमलात आणल्या जातात आणि मूलत: फक्त ॲरेपेक्षा बरेच काही असतात. परंतु हे याबद्दल नाही, परंतु "सतत मेमरीच्या तुकड्या" च्या स्वरूपात ॲरेच्या "पारंपारिक" अंमलबजावणीबद्दल आहे. या प्रकरणात, निर्देशांक आणि एका घटकाच्या आकारावर आधारित, पत्त्याची फक्त गणना केली जाते आणि संबंधित मूल्यामध्ये प्रवेश केला जातो. त्यात काय अवघड आहे?
चला ते बाहेर काढूया. उदाहरणार्थ, Java मध्ये. एका संशयित अर्जदाराला पूर्णांकांची ॲरे तयार करण्यास सांगणे n x n. व्यक्ती आत्मविश्वासाने असे काहीतरी लिहिते:
int g = नवीन int[n][n];
मस्त. आता आम्ही तुम्हाला ॲरे एलिमेंट्स कशाने तरी इनिशियल करण्यास सांगतो. किमान एककांमध्ये, किमान निर्देशांकांची बेरीज म्हणून. आम्हाला मिळते:
साठी(int i = 0; i< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } }
ते अधिक वेळा लिहितात
साठी(int i = 0; i< g.length; i++) { for(int j = 0; j < g[i].length; j++) { g[i][j] = i + j; } }
हे देखील संभाषणाचे एक कारण आहे, परंतु आता आम्ही काहीतरी वेगळे बोलत आहोत. एखाद्या व्यक्तीला काय माहित आहे आणि तो कसा विचार करतो हे आम्ही शोधण्याचा प्रयत्न करत आहोत. म्हणून, आम्ही त्याचे लक्ष वेधतो की मूल्ये सममितीयपणे स्थित आहेत आणि त्याला लूप पुनरावृत्तीवर बचत करण्यास सांगतो. अर्थात, जेव्हा तुम्ही फक्त तळाच्या त्रिकोणातून जाऊ शकता तेव्हा सर्व इंडेक्स व्हॅल्यूज का वापरता? विषय सहसा सहजपणे सहमत होतो आणि मुख्य कर्ण ठळकपणे ठळकपणे, काळजीपूर्वक असे काहीतरी लिहितो:
साठी(int i = 0; i< n; i++) { g[i][i] = 2* i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } }
g[i][i] = 2* i ऐवजी;<< 1; и это тоже повод поговорить. Но мы идем дальше и задаем ключевой вопрос: अनेकदा लिहिलेले g[i][i] = i + i;किंवा g[i][i] = i
कार्यक्रम किती वेगाने चालेल? n. सामान्य तर्क खालीलप्रमाणे आहे: जवळजवळ 2 पट कमी निर्देशांक गणना; मूल्यांची जवळजवळ 2 पट कमी गणना (संक्षेप); असाइनमेंटची समान संख्या. याचा अर्थ 30 टक्के जलद जर एखाद्या व्यक्तीची गणिताची पार्श्वभूमी चांगली असेल, तर तुम्ही सेव्ह केलेल्या ऑपरेशन्सची अचूक संख्या आणि ऑप्टिमायझेशनच्या प्रभावीतेचे अधिक तर्कसंगत मूल्यांकन देखील पाहू शकता.

आता मुख्य फटका बसण्याची वेळ आली आहे. आम्ही कोडच्या दोन्ही आवृत्त्या काही मोठ्या मूल्यावर चालवतो

(अनेक हजार), उदाहरणार्थ, यासारखे.< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nOne time " + (en - st)/1000000.d + " msc"); // two st = System.nanoTime(); for(int i = 0; i < n; i++) { g[i][i] = i + i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nTwo time " + (en - st)/1000000.d + " msc"); } }

स्पॉयलर अंतर्गत

कार्यक्रम वेळ; विंडोज वापरते;

QueryPerformanceFrequency(res); n QueryPerformanceCounter(प्रारंभ);
i साठी:=1 ते n-1 do j साठी:=1 ते n-1 do g := i + j;

QueryPerformanceCounter(समाप्त);

मुलाखती घेण्याच्या या पद्धतीचे समर्थन करण्यासाठी मी काही शब्द बोलू इच्छितो. होय, मी भाषेच्या वाक्यरचनेचे ज्ञान आणि डेटा संरचनांचे ज्ञान तपासत नाही. कदाचित, सुसंस्कृत कामगार बाजारात हे सर्व कार्य करते. परंतु आमच्याकडे पात्र कर्मचाऱ्यांच्या एकूण कमतरतेच्या परिस्थितीत, आम्हाला अर्जदाराच्या दीर्घकालीन पर्याप्ततेचे मूल्यांकन करावे लागेल ज्या कामासाठी त्याला सामोरे जावे लागेल. त्या. शिकण्याची, तोडण्याची, समजून घेण्याची, करण्याची क्षमता.
हे प्राचीन रोममधील सैन्यदलांची भरती करण्याच्या “मुलाखती” सारखेच आहे. भावी योद्धा खूप घाबरला होता आणि तो लाल झाला आहे की फिकट गुलाबी झाला आहे हे पाहत होता. जर तो फिकट गुलाबी झाला, तर तणावपूर्ण परिस्थितीत अर्जदाराच्या डोक्यातून रक्त वाहू लागते आणि त्याला निष्क्रिय प्रतिक्रिया होण्याची शक्यता असते. उदाहरणार्थ, बेहोशी. अर्जदार लालबुंद झाला तर त्याच्या डोक्यात रक्त शिरले. त्या. तो सक्रिय कृती करण्यास प्रवृत्त आहे आणि मारामारीत धावतो. हे योग्य मानले गेले.
बरं, एक शेवटची गोष्ट. मुलाखतींमध्ये ते वापरणे सुरू ठेवण्याऐवजी मी या कार्याबद्दल सर्वांना का सांगितले? हे असे आहे की संभाव्य अर्जदारांनी हे कार्य आधीच "शिकले" आहे आणि त्यांना इतरांचा वापर करावा लागेल.
वास्तविक, मी इमेज प्रोसेसिंगच्या वास्तविक कार्याच्या संबंधात या प्रभावाकडे तंतोतंत लक्ष दिले. परिस्थिती थोडी गोंधळात टाकणारी होती आणि रिफॅक्टरिंगनंतर माझे fps इतके का कमी झाले हे मला लगेच समजले नाही. सर्वसाधारणपणे, प्रत्येकाकडे असे बरेच आश्चर्यकारक क्षण असतात.

आतापर्यंत अग्रगण्य आवृत्ती प्रोसेसर कॅशे दोष आहे. त्या. पहिल्या पर्यायातील अनुक्रमिक प्रवेश हॅशमध्ये कार्य करतो, जो एका विशिष्ट सीमेच्या पलीकडे जाताना अद्यतनित केला जातो. स्तंभांद्वारे प्रवेश करताना, हॅशला सतत अद्यतनित करण्याची सक्ती केली जाते आणि यास बराच वेळ लागतो. चला ही आवृत्ती त्याच्या शुद्ध स्वरूपात पाहू. चला एक ॲरे तयार करू आणि वेगवान काय आहे याची तुलना करू - एका ओळीतील सर्व घटकांवर प्रक्रिया करण्यासाठी किंवा यादृच्छिक संख्येसह ॲरे घटकांवर समान संख्येने प्रक्रिया करण्यासाठी? हा कार्यक्रम ideone.com/tMaR2S आहे. 100,000 ॲरे घटकांसाठी, यादृच्छिक प्रवेश सहसा लक्षणीयरीत्या जलद असतो. याचा अर्थ काय?
येथे मला (बिग_लेबोव्स्की) अगदी बरोबर निदर्शनास आणले होते की लूपची पुनर्रचना केल्याने परिणाम अनुक्रमिक पर्यायाच्या बाजूने बदलतात. प्रयोगाच्या शुद्धतेसाठी, मला एक वॉर्म-अप सायकल सेट करावी लागली. त्याच वेळी, लेव्हेंटोव्हच्या सल्ल्यानुसार सरासरी ऑपरेटिंग वेळ मिळविण्यासाठी मी अनेक पुनरावृत्ती केल्या. हे असे झाले ideone.com/yN1H4g. त्या. मोठ्या ॲरेच्या घटकांचा यादृच्छिक प्रवेश अनुक्रमिक प्रवेशापेक्षा ~10% कमी आहे. कदाचित कॅशे प्रत्यक्षात काही भूमिका बजावू शकेल. तथापि, मूळ स्थितीत, कामगिरी लक्षणीयरीत्या घसरली. त्यामुळे आणखी काही आहे.

हळुहळू, ॲरेच्या एका ओळीतून दुसऱ्या ओळीत जाताना अतिरिक्त क्रियांची आवृत्ती लीडर बनत आहे. आणि ते बरोबर आहे. तिथे नेमके काय चालले आहे हे शोधणे बाकी आहे.

टॅग्ज:

• प्रोग्रामिंग
• ॲरे
• स्मृती

ॲरेएक डेटा संरचना आहे जी समान प्रकारचा डेटा संचयित करण्यासाठी डिझाइन केलेली आहे. ॲरे C/C++ पेक्षा Java मध्ये वेगळ्या पद्धतीने काम करतात. वैशिष्ठ्य:

• ॲरे हे ऑब्जेक्ट्स असल्यामुळे त्यांची लांबी आपण शोधू शकतो. हे C/C++ पेक्षा वेगळे आहे जिथे आपण sizeof वापरून लांबी शोधतो.
• ॲरे व्हेरिएबल देखील असू शकते.
• व्हेरिएबल्स ऑर्डर केले आहेत आणि त्यांची अनुक्रमणिका 0 पासून सुरू होते.
• स्टॅटिक फील्ड, स्थानिक व्हेरिएबल किंवा पद्धत पॅरामीटर म्हणून देखील वापरले जाऊ शकते.
• ॲरेचा आकार इंट म्हणून निर्दिष्ट केला जाणे आवश्यक आहे, लांब किंवा लहान नाही.
• ॲरे प्रकाराचा थेट सुपरक्लास ऑब्जेक्ट आहे.
• प्रत्येक ॲरे प्रकार Cloneable आणि java.io.Serializable इंटरफेस लागू करतो.

प्रारंभ आणि ॲरे प्रवेश

एक-आयामी ॲरे: घोषणांचे सामान्य स्वरूप

var-नाव टाइप करा; किंवा var-name टाइप करा;

घोषणेमध्ये दोन घटक असतात: एक प्रकार आणि नाव. type ॲरे घटकाचा प्रकार घोषित करतो. घटक प्रकार प्रत्येक घटकाचा डेटा प्रकार निर्धारित करतो.

इंट प्रकाराव्यतिरिक्त, आम्ही इतर डेटा प्रकार जसे की चार, फ्लोट, दुहेरी किंवा वापरकर्ता परिभाषित डेटा प्रकार (क्लास ऑब्जेक्ट्स) देखील तयार करू शकतो अशा प्रकारे, ॲरेमध्ये कोणत्या प्रकारचा डेटा संग्रहित केला जाईल हे घटक प्रकार निर्धारित करते. उदाहरणार्थ:

// दोन्ही वैध घोषणा आहेत int intArray; किंवा int intArray; byte byteArray; शॉर्ट्स ॲरे; बुलियन बूलियन ॲरे; लांब लांब ॲरे; float floatArray; दुहेरी दुहेरी ॲरे; char charArray; // वर्ग MyClass (// वापरकर्त्याने तयार केलेला वर्ग) मायक्लास myClassArray; ऑब्जेक्ट एओ, // ऑब्जेक्ट कलेक्शन ca; // संग्रहाचा ॲरे // अज्ञात प्रकाराचा

जरी वरील पहिल्या घोषणेने intArray एक ॲरे व्हेरिएबल आहे हे सत्य स्थापित केले असले तरी, ॲरे प्रत्यक्षात अस्तित्वात नाही. हे कंपाइलरला सहज सांगते की हे व्हेरिएबल पूर्णांक प्रकाराचे आहे.

पूर्णांकांच्या वास्तविक भौतिक ॲरेसह इंट ॲरे संबद्ध करण्यासाठी, तुम्हाला ते नवीनसह सूचित करावे लागेल आणि ते int ला नियुक्त करावे लागेल.

Java मध्ये ॲरे कसा तयार करायचा

ॲरे घोषित करताना, ॲरेचा फक्त संदर्भ तयार केला जातो. ॲरेमध्ये मेमरी तयार करण्यासाठी किंवा वाटप करण्यासाठी, तुम्हाला याप्रमाणे ॲरे तयार करणे आवश्यक आहे: एक-आयामी वर लागू केल्यावर नवीनचे सामान्य रूप खालीलप्रमाणे आहे:
var-name = नवीन प्रकार;

येथे प्रकार डेटा प्रकार दर्शवतो, आकार ॲरेमधील घटकांची संख्या आहे आणि var-name हे ॲरे व्हेरिएबलचे नाव आहे.

intArray; //declaration intArray = नवीन int; // मेमरी वाटप

Int intArray = new int; // युनियन

हे जाणून घेणे महत्त्वाचे आहे की नवीन फंक्शनद्वारे वाटप केलेले ॲरे घटक स्वयंचलितपणे शून्य (संख्यात्मक प्रकारांसाठी), असत्य (बूलियन प्रकारांसाठी) किंवा शून्य (संदर्भ प्रकारांसाठी) सुरू केले जातात.
ॲरे पुनर्प्राप्त करणे ही दोन-चरण प्रक्रिया आहे. प्रथम, आपल्याला इच्छित प्रकाराचे व्हेरिएबल घोषित करणे आवश्यक आहे. दुसरे म्हणजे, तुम्हाला नवीन वापरून ॲरे असलेली मेमरी वाटप करावी लागेल आणि ती व्हेरिएबलला द्यावी लागेल. अशा प्रकारे, जावामध्ये, सर्व ॲरे डायनॅमिक पद्धतीने वाटप केले जातात.

ॲरे अक्षरे

ॲरे आकार आणि व्हेरिएबल्स आधीपासूनच ज्ञात आहेत अशा परिस्थितीत, अक्षरे वापरली जाऊ शकतात.

Int intArray = नवीन int( 1,2,3,4,5,6,7,8,9,10);

• // ॲरे शाब्दिक घोषित करणे
• या ॲरेची लांबी तयार केलेल्या ॲरेची लांबी ठरवते.

Java च्या नवीनतम आवृत्त्यांमध्ये int लिहिण्याची गरज नाही

फॉर लूप वापरून Java ॲरे घटकांमध्ये प्रवेश करणे

प्रत्येक ॲरे घटक त्याच्या अनुक्रमणिकेद्वारे प्रवेश केला जातो. निर्देशांक 0 पासून सुरू होतो आणि (एकूण आकार) -1 वर समाप्त होतो. फॉर लूप वापरून सर्व घटकांमध्ये प्रवेश केला जाऊ शकतो.< arr.length; i++) System.out.println("Element at index " + i + " : "+ arr[i]);

साठी (int i = 0; i
// ॲरेची निर्मिती स्पष्ट करण्यासाठी एक उदाहरण
// पूर्णांक, काही मूल्ये ॲरेमध्ये ठेवतात,

// आणि प्रत्येक मूल्य मुद्रित करते.
{

{

वर्ग GFG

int arr;
// 5 पूर्णांकांसाठी मेमरी वाटप.

arr = नवीन इंट;

arr = 10;

arr = 20;
//असेच...
arr = 30;
arr = 40;

arr = 50;
साठी (int i = 0; i< arr.length; i++)
// निर्दिष्ट ॲरेच्या घटकांमध्ये प्रवेश करणे
System.out.println("इंडेक्समधील घटक" + i +
}
}
" : "+ arr[i]);

परिणामी आम्हाला मिळते:

अनुक्रमणिका 0: 10 वरील घटक 1: 20 अनुक्रमणिका 2: 30 घटक अनुक्रमणिका 3: 40 वरील घटक 4: 50

वस्तूंचे ॲरे

खालीलप्रमाणे डेटा घटकांप्रमाणेच ऑब्जेक्ट्सची ॲरे तयार केली जाते:

StudentArray मध्ये प्रत्येक विद्यार्थी वर्गात सात मेमरी घटक असतात, ज्यामध्ये सात विद्यार्थी वस्तूंचे पत्ते संग्रहित केले जाऊ शकतात. स्टुडंट क्लास कन्स्ट्रक्टर वापरून विद्यार्थी ऑब्जेक्ट्स तयार केल्या पाहिजेत आणि त्यांचे संदर्भ खालीलप्रमाणे ॲरे घटकांना नियुक्त केले पाहिजेत:

खालीलप्रमाणे डेटा घटकांप्रमाणेच ऑब्जेक्ट्सची ॲरे तयार केली जाते:

// ची ॲरे तयार करण्यासाठी जावा प्रोग्राम
// वस्तू

वर्ग विद्यार्थी
{
सार्वजनिक इंट रोल_नो;
सार्वजनिक स्ट्रिंग नाव;
विद्यार्थी (इंट रोल_नो, स्ट्रिंग नाव)
{
this.roll_no = रोल_नो;
this.name = नाव;
}
}

// ॲरेचे घटक वर्ग विद्यार्थ्याच्या वस्तू आहेत.
सार्वजनिक वर्ग GFG
{
सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग आर्ग्स)
{
// पूर्णांकांची ॲरे घोषित करते.
विद्यार्थी arr;

// स्टुडंट प्रकारच्या 5 वस्तूंसाठी मेमरी वाटप.
arr = नवीन विद्यार्थी;

// ॲरेचे पहिले घटक सुरू करा
arr = नवीन विद्यार्थी(1,"अमन");

// ॲरेचे दुसरे घटक सुरू करा
arr = नवीन विद्यार्थी(2,"वैभव");

//असेच...
arr = नवीन विद्यार्थी(3,"शिकार");
arr = नवीन विद्यार्थी(4,"धर्मेश");
arr = नवीन विद्यार्थी(5,"मोहित");

arr = 50;
साठी (int i = 0; i< arr.length; i++)
System.out.println("घटक " + i + " : " + वर
arr[i].roll_no +" "+ arr[i].name);
}
}

आम्हाला मिळते:

0:1 अमन एलिमेंट 1:2 वाजता वैभव एलिमेंट 2:3 शिकार एलिमेंट 3:4 धर्मेश एलिमेंट 4:5 मोहित

जर आपण ॲरेच्या बाहेरील घटकामध्ये प्रवेश करण्याचा प्रयत्न केला तर काय होईल?
कंपाइलर एक ArrayIndexOutOfBoundsException फेकतो जो सूचित करतो की ॲरे अवैध इंडेक्सवर ऍक्सेस केला गेला होता. निर्देशांक एकतर ऋणात्मक आहे किंवा ॲरेच्या आकारापेक्षा जास्त आहे.

बहुआयामी

बहुआयामी ॲरे हे ॲरेचे ॲरे असतात ज्यात प्रत्येक घटकामध्ये दुसऱ्या ॲरेचा संदर्भ असतो. प्रत्येक परिमाणासाठी चौरस कंसाचा एक संच () जोडून तयार केले. चला एक उदाहरण पाहू:

Int intArray = new int; //a 2D ॲरे किंवा मॅट्रिक्स int intArray = नवीन int; //a 3D ॲरे

वर्ग बहुआयामी
{
सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग आर्ग्स)
{
// 2D ॲरे घोषित करणे आणि आरंभ करणे
int arr = ( (2,7,9),(3,6,1),(7,4,2));

// प्रिंटिंग 2D ॲरे
साठी (int i=0; i< 3 ; i++)
{
साठी (int j=0; j< 3 ; j++)
System.out.print(arr[i][j] + "");

System.out.println();
}
}
}

आउटपुट: 2 7 9 3 6 1 7 4 2

एका पद्धतीमध्ये ॲरे पास करणे

व्हेरिएबल्स प्रमाणेच, आपण पद्धतींमध्ये ॲरे पास करू शकतो.

// मेथड क्लास टेस्टमध्ये ॲरे पासिंगचे प्रात्यक्षिक करण्यासाठी // Java प्रोग्राम m1 sum(arr); पब्लिक स्टॅटिक void sum(int arr) (// ॲरे मूल्यांची बेरीज int sum = 0; साठी (int i = 0; i)< arr.length; i++) sum+=arr[i]; System.out.println("sum of array values: " + sum); } }

आउटपुटवर आम्हाला मिळते:

ॲरे मूल्यांची बेरीज: 15

पद्धतींमधून ॲरे परत करत आहे

नेहमीप्रमाणे, पद्धत ॲरे देखील परत करू शकते. उदाहरणार्थ, खालील प्रोग्राम m1 पद्धतीवरून ॲरे देतो.

// मेथड क्लास टेस्ट (// ड्रायव्हर मेथड पब्लिक स्टॅटिक व्हॉइड मेन(स्ट्रिंग आर्ग्स) ( int arr = m1(); साठी (int i = 0; i< arr.length; i++) System.out.print(arr[i]+" "); } public static int m1() { // returning array return new int{1,2,3}; } }

वर्ग वस्तू

प्रत्येक ॲरेमध्ये संबंधित क्लास ऑब्जेक्ट असतो जो समान घटक प्रकारासह इतर सर्व ॲरेसह सामायिक केला जातो.

// ॲरे क्लास टेस्टसाठी क्लास ऑब्जेक्ट्स दाखवण्यासाठी // जावा प्रोग्राम ( पब्लिक स्टॅटिक व्हॉइड मेन (स्ट्रिंग आर्ग्स) ( int intArray = नवीन int; byte byteArray = नवीन बाइट; शॉर्ट शॉर्ट्सॲरे = नवीन शॉर्ट; // स्ट्रिंग्सचे ॲरे स्ट्रिंग strArray = नवीन स्ट्रिंग; System.out.println(intArray.getClass().getSuperclass()); getClass()); System.out.println(strArray.getClass());

वर्ग +""); ) ) )

बहुआयामी ॲरेचा क्लोन (जसे की ऑब्जेक्ट ) ही एक प्रत आहे, म्हणजे ती प्रत्येक घटकासह फक्त एक नवीन ॲरे तयार करते आणि घटकांच्या मूळ ॲरेचा संदर्भ देते, परंतु नेस्टेड ॲरे सामायिक केले जातात.

// बहु-आयामी ॲरे वर्ग चाचणीचे // क्लोनिंग प्रदर्शित करण्यासाठी Java प्रोग्राम ( सार्वजनिक स्थिर शून्य मुख्य(स्ट्रिंग आर्ग्स) ( int intArray = ((1,2,3),(4,5)); int cloneArray = intArray. clone(); // खोटे System.out.println (intArray == cloneArray) मुद्रित करेल; // उथळ प्रत तयार केली जाईल // म्हणजे, System.out.println (intArray == cloneArray) ; System.out.println(intArray == cloneArray) )