मालवेअर हे अनाहूत किंवा धोकादायक प्रोग्राम आहेत जे...
ॲरे हा एकाच प्रकारच्या क्रमबद्ध घटकांचा मर्यादित क्रम असतो, प्रत्येक घटक ज्यामध्ये त्याच्या अनुक्रमणिकेद्वारे प्रवेश केला जातो.
ॲरेचा आकार किंवा लांबी ही ॲरेमधील घटकांची एकूण संख्या असते. ॲरे तयार केल्यावर ॲरेचा आकार सेट केला जातो आणि नंतर बदलला जाऊ शकत नाही, म्हणजेच तुम्ही ॲरेमधून घटक काढू शकत नाही किंवा त्यांना तेथे जोडू शकत नाही, परंतु तुम्ही विद्यमान घटकांना नवीन मूल्ये नियुक्त करू शकता.
सुरुवातीच्या घटकाची अनुक्रमणिका 0 आहे, पुढील 1 आहे, इ. ॲरेमधील शेवटच्या घटकाची अनुक्रमणिका ॲरेच्या आकारापेक्षा एक कमी आहे.
Java मध्ये, ॲरे हे ऑब्जेक्ट्स असतात. याचा अर्थ प्रत्येक ॲरेला दिलेले नाव केवळ मेमरीमधील डेटाच्या काही भागाचा पत्ता सूचित करते. या व्हेरिएबलमध्ये पत्त्याशिवाय काहीही साठवले जात नाही. ॲरे इंडेक्स, खरं तर, इच्छित घटकापर्यंत जाण्यासाठी तुम्हाला मेमरीमधील ॲरेच्या सुरुवातीच्या घटकापासून किती दूर जाण्याची आवश्यकता आहे हे सूचित करते.
ॲरे तयार करण्यासाठी, तुम्हाला त्यासाठी एक सुयोग्य नाव घोषित करण्याची आवश्यकता आहे आणि नंतर स्मृतीच्या इच्छित तुकड्याशी संबंध जोडणे आवश्यक आहे, जेथे ॲरे एलिमेंट्सची व्हॅल्यूज एकामागून एक संग्रहित केली जातील शक्य आहेत: नाव टाइप करा; नाव टाइप करा;
कुठे प्रकारॲरे घटकांचा प्रकार आहे, आणि नाव- एक अद्वितीय (प्रोग्रामच्या या भागात इतर व्हेरिएबल्स किंवा ऑब्जेक्ट्सद्वारे व्यापलेले नाही) अक्षराने सुरू होणारा अभिज्ञापक.
उदाहरणे: int a; दुहेरी ar1; दुहेरी ar2;
उदाहरणात, आम्ही तीन ॲरेसाठी नावे घोषित केली. पहिल्या नावासह a int प्रकारातील घटकांची ॲरे पुढे आणि नावांसह संबद्ध केली जाऊ शकते ar1आणि ar2पुढे, वास्तविक संख्यांचे ॲरे (टाईप डबल) जोडले जाऊ शकतात. आतापर्यंत आम्ही ॲरे तयार केले नाहीत, परंतु त्यांच्यासाठी फक्त नावे तयार केली आहेत.
आता तुम्ही खालीलप्रमाणे ॲरे तयार करू शकता (किंवा, जसे ते म्हणतात, आरंभ करा) a = new int; int int n = 5 प्रकारातील 10 घटकांचा // ॲरे; ar1 = नवीन दुहेरी[n]; // 5 घटकांचा ॲरे दुहेरी ar2 = (3.14, 2.71, 0, -2.5, 99.123); // दुहेरी प्रकारातील 6 घटकांचा ॲरे म्हणजेच ॲरे तयार करताना, आम्ही त्याचा आकार निर्दिष्ट करू शकतो किंवा कुरळे ब्रेसेसमध्ये स्वल्पविरामाने विभक्त केलेले सर्व इच्छित घटक ताबडतोब सूचीबद्ध करू शकतो (या प्रकरणात, आकार स्वयंचलितपणे गणना केली जाईल घटकांचा क्रम जो निर्दिष्ट केला जाईल). कृपया लक्षात घ्या की या प्रकरणात, क्लोजिंग कर्ली ब्रेस नंतर अर्धविराम ठेवला जातो, जे ब्रेस ब्लॉक बंद करते तेव्हा होत नाही.
ऑपरेटर वापरून ॲरे तयार केले असल्यास नवीन, नंतर त्यातील प्रत्येक घटकाला डीफॉल्ट मूल्य प्राप्त होते. ते काय असेल ते डेटा प्रकारावर (इंटरसाठी 0, दुहेरीसाठी 0.0 इ.) च्या आधारे निर्धारित केले जाते.
ॲरेसाठी नाव घोषित करणे आणि खालील योजना वापरून ॲरे स्वतःच एका ओळीवर तयार करणे शक्य होते: type name = new type[size]; प्रकार नाव = (el0, el1, ..., elN); उदाहरणे: int mas1 = (10,20,30); int mas2 = नवीन int;
ॲरेच्या घटकांपैकी एकामध्ये प्रवेश करण्यासाठी त्याचे मूल्य वाचण्यासाठी किंवा बदलण्यासाठी, तुम्हाला ॲरेचे नाव आणि चौरस कंसातील घटकाची अनुक्रमणिका निर्दिष्ट करणे आवश्यक आहे. विशिष्ट निर्देशांकासह ॲरे घटक व्हेरिएबल प्रमाणेच वागतात. उदाहरणार्थ, mas1 ॲरेचा शेवटचा घटक प्रदर्शित करण्यासाठी, आपल्याला प्रोग्राममध्ये लिहावे लागेल:
System.out.println("अंतिम ॲरे घटक " + mas1);
आणि अशा प्रकारे आपण mas2 ॲरेमध्ये mas1 मध्ये संग्रहित केलेल्या मूल्यांचा समान संच ठेवू शकतो:
Mas2 = 10; mas2 = 20; mas2 = 30;आधीच या उदाहरणावरून हे स्पष्ट आहे की ॲरेच्या सर्व घटकांमध्ये प्रवेश करण्यासाठी, आपल्याला एकाच प्रकारच्या क्रियांची पुनरावृत्ती करावी लागेल. जसे तुम्हाला आठवते, लूप अनेक वेळा ऑपरेशन्सची पुनरावृत्ती करण्यासाठी वापरले जातात. त्यानुसार, आम्ही लूप वापरून आवश्यक घटकांसह ॲरे भरू शकतो: for(int i=0; iI हे स्पष्ट आहे की जर आमच्याकडे 3 नसून 100 घटकांचा ॲरे असेल तर आम्ही ते करू शकलो नसतो. लूपशिवाय.
तयार केलेल्या कोणत्याही ॲरेची लांबी लक्षात ठेवण्याची गरज नाही, कारण तेथे एक गुणधर्म आहे जो तो संग्रहित करतो. ॲरे नावात .length जोडून तुम्ही या गुणधर्मात प्रवेश करू शकता. उदाहरणार्थ:
Int razmer = mas1.length; ही मालमत्ता सुधारली जाऊ शकत नाही (म्हणजे, ती काहीही नियुक्त केली जाऊ शकत नाही), ती फक्त वाचली जाऊ शकते. या गुणधर्माचा वापर करून, तुम्ही ॲरेवर प्रक्रिया करण्यासाठी प्रोग्राम कोड लिहू शकता त्याचा विशिष्ट आकार न कळता.
उदाहरणार्थ, तुम्ही ar2 नावाच्या कोणत्याही ॲरेचे घटक कसे प्रदर्शित करू शकता:
साठी(int i = 0; i<= ar2.length - 1; i++) { System.out.print(ar2[i] + " "); } Для краткости удобнее менять нестрогое неравенство на строгое, тогда не нужно будет вычитать единицу из размера массива. Давайте заполним массив целыми числами от 0 до 9 и выведем его на экран: for(int i = 0; i < ar1.length; i++) {ar1[i] = Math.floor(Math.random() * 10); System.out.print(ar1[i] + " "); }
कृपया लक्षात घ्या की लूपच्या प्रत्येक पायरीवर, आम्ही प्रथम i-th इंडेक्ससह ॲरे घटकाला एक यादृच्छिक मूल्य पाठवले आणि नंतर तोच घटक स्क्रीनवर प्रदर्शित केला. परंतु दोन प्रक्रिया (भरणे आणि काढणे) वेगवेगळ्या चक्रांमध्ये करता येऊ शकतात. उदाहरणार्थ:
साठी(int i = 0; i< ar1.length; i++) { ar1[i] = Math.floor(Math.random() * 9); } for(int i = 0; i < ar1.length; i++) { System.out.print(ar1[i] + " "); } В данном случае более рационален первый способ (один проход по массиву вместо двух), но не всегда возможно выполнить требуемые действия в одном цикле.
ॲरेवर प्रक्रिया करण्यासाठी, “n वेळा” (साठी) प्रकारच्या लूप नेहमी वापरल्या जातात कारण लूप किती वेळा रिपीट व्हायचा हे आम्हाला आधीच माहीत असते (ॲरेमध्ये जेवढे घटक असतात तेवढ्याच वेळा).
कार्ये
2 ते 20 पर्यंत सर्व सम संख्यांचा ॲरे तयार करा आणि ॲरेचे घटक प्रथम एका ओळीत प्रदर्शित करा, एका घटकाला स्पेससह दुसऱ्यापासून वेगळे करा आणि नंतर स्तंभात (नवीन ओळ सुरू करून एक घटक दुसऱ्यापासून विभक्त करा). ॲरे तयार करण्यापूर्वी, ते किती मोठे असेल याचा विचार करा.
2 4 6 … 18 20
2
4
6
…
20
1 ते 99 पर्यंतच्या सर्व विषम संख्यांचा एक ॲरे तयार करा, स्क्रीनवर एक रेषा म्हणून प्रदर्शित करा आणि नंतर स्क्रीनवर समान ॲरे एका ओळीच्या रूपात प्रदर्शित करा, परंतु उलट क्रमाने (99 97 95 93 ... 7 5 3 1 ).
विभागातून 15 यादृच्छिक पूर्णांकांची ॲरे तयार करा. स्क्रीनवर ॲरे प्रदर्शित करा. ॲरेमध्ये किती सम घटक आहेत ते मोजा आणि ही संख्या स्क्रीनवर वेगळ्या ओळीवर प्रदर्शित करा.
सेगमेंटमधून 8 यादृच्छिक पूर्णांकांची ॲरे तयार करा. स्ट्रिंग म्हणून स्क्रीनवर ॲरे प्रिंट करा. प्रत्येक घटकाला विषम निर्देशांकाने शून्याने बदला. पुन्हा, वेगळ्या ओळीवर ॲरे प्रदर्शित करा.
प्रत्येक सेगमेंटमधून 5 यादृच्छिक पूर्णांकांचे 2 ॲरे तयार करा, ॲरे दोन वेगळ्या ओळींवर स्क्रीनवर प्रदर्शित करा. प्रत्येक ॲरेच्या घटकांच्या अंकगणितीय माध्याची गणना करा आणि कोणत्या ॲरेसाठी हे मूल्य जास्त होते (किंवा त्यांचे अंकगणितीय अर्थ समान आहेत असा अहवाल द्या).
सेगमेंटमधून 4 यादृच्छिक पूर्णांकांची ॲरे तयार करा, स्ट्रिंग म्हणून स्क्रीनवर मुद्रित करा. ॲरे हा काटेकोरपणे वाढणारा क्रम आहे की नाही हे दर्शवणारा संदेश निश्चित करा आणि प्रदर्शित करा.
शीर्ष 20 फिबोनाची संख्यांचा एक ॲरे तयार करा आणि ते स्क्रीनवर प्रदर्शित करा. आम्ही तुम्हाला स्मरण करून देतो की अनुक्रमाचे पहिले आणि व्यस्तीय पद समसमान आहेत आणि प्रत्येक पुढील मागील दोनची बेरीज आहे.
सेगमेंट [-15;15] मधून 12 यादृच्छिक पूर्णांकांची ॲरे तयार करा. या ॲरेमध्ये कोणता घटक कमाल आहे ते ठरवा आणि ॲरेमध्ये त्याच्या शेवटच्या घटनेचा निर्देशांक नोंदवा.
विभागातून 10 यादृच्छिक पूर्णांकांचे दोन ॲरे आणि 10 वास्तविक संख्यांचा तिसरा ॲरे तयार करा. तिसऱ्या ॲरेच्या i-th इंडेक्ससह प्रत्येक घटक पहिल्या ॲरेपासून i-th इंडेक्ससह दुसऱ्या ॲरेमधील घटकाच्या i-th इंडेक्सच्या गुणोत्तराच्या समान असणे आवश्यक आहे. स्क्रीनवर सर्व तीन ॲरे प्रिंट करा (प्रत्येक वेगळ्या ओळीवर), नंतर तिसऱ्या ॲरेमधील पूर्णांक घटकांची संख्या मुद्रित करा.
सेगमेंट [-1;1] मधून 11 यादृच्छिक पूर्णांकांचा एक ॲरे तयार करा, ॲरेला ओळ म्हणून प्रदर्शित करा. ॲरेमध्ये कोणता घटक बहुतेकदा आढळतो ते ठरवा आणि त्याबद्दलचा संदेश स्क्रीनवर प्रदर्शित करा. जर दोन घटक एकाच संख्येने येत असतील तर काहीही आउटपुट करू नका.
वापरकर्त्याने कीबोर्डवरून एक समान सकारात्मक संख्या निर्दिष्ट करणे आवश्यक आहे आणि प्रोग्रामने [-5;5] पासून यादृच्छिक पूर्णांकांमधून निर्दिष्ट आकाराचा ॲरे तयार केला पाहिजे आणि तो स्क्रीनवर एका ओळीच्या रूपात प्रदर्शित केला पाहिजे. यानंतर, प्रोग्रामने वापरकर्त्याला मॉड्यूल्सची बेरीज निश्चित करणे आणि सूचित करणे आवश्यक आहे ज्यापैकी अर्धा ॲरे जास्त आहे: डावीकडे किंवा उजवीकडे, किंवा सूचित करणे आवश्यक आहे की या मॉड्यूल्सची बेरीज समान आहेत. वापरकर्त्याने चुकीची संख्या प्रविष्ट केल्यास, योग्य मूल्य निर्दिष्ट होईपर्यंत प्रोग्रामला पुनरावृत्ती प्रविष्ट करणे आवश्यक आहे.
प्रोग्रामने सेगमेंट [-१०;१०] मधून १२ यादृच्छिक पूर्णांकांची ॲरे तयार करणे आवश्यक आहे जेणेकरुन नकारात्मक आणि सकारात्मक घटकांची संख्या समान असेल आणि शून्य नसेल. या प्रकरणात, घटकांचा क्रम यादृच्छिक असणे आवश्यक आहे (म्हणजे, जेव्हा ॲरेमध्ये सतत प्रथम 6 सकारात्मक आणि नंतर 6 ऋण संख्या असतात, किंवा जेव्हा घटक सतत एकाद्वारे वैकल्पिक असतात, इ.) तेव्हा पर्याय योग्य नाही. स्क्रीनवर परिणामी ॲरे प्रदर्शित करा.
वापरकर्ता कीबोर्डवरून 3 पेक्षा मोठी नैसर्गिक संख्या प्रविष्ट करतो, जी व्हेरिएबल n मध्ये संग्रहित केली जाते. जर वापरकर्त्याने चुकीचा क्रमांक प्रविष्ट केला असेल तर, प्रोग्रामने वापरकर्त्यास इनपुटची पुनरावृत्ती करण्यास सांगावे. सेगमेंटमधून n यादृच्छिक पूर्णांकांची ॲरे तयार करा आणि ती स्क्रीनवर प्रदर्शित करा. पहिल्या ॲरेच्या सम घटकांपासूनच दुसरा ॲरे तयार करा, जर असेल तर, आणि तो स्क्रीनवर प्रदर्शित करा.
ॲरे क्रमवारी लावा
क्रमवारी लावणे ही ॲरेच्या घटकांची पुनर्रचना करण्याची प्रक्रिया आहे, जेव्हा त्याचे सर्व घटक चढत्या किंवा उतरत्या क्रमाने मांडले जातात तेव्हा तुम्ही केवळ अंकीय ॲरेच नाही तर स्ट्रिंग ॲरे देखील क्रमवारी लावू शकता (पुस्तके ज्या तत्त्वावर मांडली जातात त्याच तत्त्वानुसार. लायब्ररी शेल्फ् 'चे अव रुप). सर्वसाधारणपणे, तुम्ही कोणत्याही सेटच्या घटकांची क्रमवारी लावू शकता जिथे ऑर्डर रिलेशन निर्दिष्ट केले आहे तेथे सार्वत्रिक अल्गोरिदम आहेत जे ॲरेची प्रारंभिक स्थिती कशी होती याची पर्वा न करता क्रमवारी लावतात. परंतु त्यांच्या व्यतिरिक्त, असे विशेष अल्गोरिदम आहेत जे, उदाहरणार्थ, जवळजवळ ऑर्डर केलेल्या ॲरेला त्वरीत क्रमवारी लावू शकतात, परंतु मोठ्या प्रमाणात मिश्रित ॲरेचा सामना करू शकत नाहीत (किंवा अजिबात सामना करू नका). विशेष अल्गोरिदम आवश्यक आहेत जेथे वेग महत्त्वाचा आहे आणि विशिष्ट समस्या सोडवली जात आहे त्यांचा तपशीलवार अभ्यास आमच्या अभ्यासक्रमाच्या पलीकडे आहे.निवडीनुसार क्रमवारी लावत आहे
चढत्या क्रमाने क्रमवारी लावण्याचे उदाहरण पाहू. म्हणजेच, ॲरेमधील सुरुवातीच्या स्थितीत किमान घटक असावेत, पुढच्या स्थितीत मोठे किंवा समान घटक असावेत, आणि शेवटच्या स्थितीत सर्वात मोठा घटक असावा. आम्ही प्रत्येक गोष्टीत किमान घटक शोधतो आणि त्यास सुरुवातीच्या घटकासह बदलतो. त्यानंतर, ॲरेच्या उर्वरित भागात (म्हणजे प्रारंभिक घटक वगळता सर्व घटकांमध्ये), आम्ही पुन्हा किमान घटक शोधतो आणि ॲरेमधील दुसऱ्या घटकासह स्वॅप करतो. वगैरे.चित्रण:
साठी (int i = 0; i
बबल क्रमवारी
अल्गोरिदमचे सार हे आहे. जर आपण कोणत्याही ॲरेमधून गेलो, प्रत्येक समीप घटकांच्या जोडीमध्ये योग्य क्रम प्रस्थापित केला, तर त्या पास केल्यानंतर इच्छित घटक ॲरेच्या शेवटच्या ठिकाणी असण्याची हमी दिली जाईल (चढत्या क्रमाने क्रमवारी लावण्यासाठी सर्वात मोठा किंवा वर्गीकरणासाठी सर्वात लहान उतरत्या क्रमाने). तुम्ही समान परिवर्तनांसह पुन्हा ॲरेमधून गेल्यास, इच्छित घटक उपांत्य ठिकाणी असण्याची हमी दिली जाते. आणि असेच उदाहरण:2 9 1 4 3 5 2 → ऑर्डर योग्य आहे, कोणतीही पुनर्रचना होणार नाही
2 9 1 4 3 5 2 → 2 1 9 4 3 5 2
2 1 9 4 3 5 2 → 2 1 4 9 3 5 2
2 1 4 9 3 5 2 → 2 1 4 3 9 5 2
2 1 4 3 9 5 2 → 2 1 4 3 5 9 2
2 1 4 3 5 9 2 → 2 1 4 3 5 2 9
कोड: /* बाह्य लूप सतत ॲरेच्या तुकड्याला संकुचित करते * ज्याचा विचार केला जाईल, कारण अंतर्गत लूपच्या प्रत्येक पास * नंतर, इच्छित घटक तुकड्याच्या शेवटच्या ठिकाणी * असेल (त्याची आवश्यकता नाही पुन्हा विचार केला जाईल). */ साठी (int i = a.length - 1; i >= 2; i--) ( /* सॉर्ट केलेल्या व्हेरिएबलमध्ये आपण ॲरे * सॉर्ट केले आहे की नाही याचे चिन्ह साठवू. अंतर्गत * लूपच्या प्रत्येक पास करण्यापूर्वी आम्ही असे गृहीत धरू की ते क्रमवारी लावले आहे, परंतु जर आपण * किमान एक क्रमवारी लावले तर ते अद्याप पूर्णपणे क्रमवारी लावलेले नाही * हे तंत्र, जे वर्गीकरण सोपे करते, त्याला आयव्हरसन निकष म्हणतात */ बुलियन सॉर्टेड = सत्य; आतील लूप, आम्ही ॲरे फ्रॅगमेंटमधून जातो, जे * बाहेरील लूपद्वारे निर्धारित केले जाते. ( int temp = a[j]; a[j] = a; a = temp. ; sorted = false; ) ) /* जर ॲरे क्रमवारी लावला असेल (म्हणजे आतील लूपमध्ये कोणतेही क्रमपरिवर्तन नव्हते *, तर तुम्ही थांबू शकता बाह्य * लूप */ जर (क्रमबद्ध) ( खंडित; ) )
बहुआयामी ॲरे
ॲरेमध्ये केवळ काही बिल्ट-इन प्रकार (इंट, दुहेरी, इ.) घटक नसतात, परंतु इतर गोष्टींबरोबरच, काही विद्यमान वर्गाच्या वस्तू आणि इतर ॲरे देखील असू शकतात.
ज्या ॲरेमध्ये इतर ॲरे असतात, त्याला बहुआयामी ॲरे म्हणतात. अशा ॲरे सहजपणे मॅट्रिक्स म्हणून दर्शविले जाऊ शकतात. ज्यातील प्रत्येक पंक्ती एक सामान्य एक-आयामी ॲरे आहे आणि सर्व पंक्तींचे एकत्रीकरण एक द्विमितीय ॲरे आहे, ज्याच्या प्रत्येक घटकामध्ये मॅट्रिक्सच्या काही पंक्तीची लिंक संग्रहित केली जाऊ शकते मॅट्रिक्सचा संच म्हणून कल्पना केली, ज्यापैकी प्रत्येक आम्ही लायब्ररी कार्डवर लिहून ठेवतो. त्यानंतर, विशिष्ट क्रमांकावर जाण्यासाठी, तुम्हाला प्रथम कार्ड क्रमांक (त्रिमीय ॲरेचा पहिला निर्देशांक) सूचित करणे आवश्यक आहे, म्हणून पंक्ती क्रमांक (दुसरा ॲरे निर्देशांक) सूचित करा आणि त्यानंतरच मधील घटकाची संख्या. पंक्ती (तिसरा निर्देशांक).
त्यानुसार, n-मितीय ॲरेच्या घटकामध्ये प्रवेश करण्यासाठी, तुम्हाला n निर्देशांक निर्दिष्ट करणे आवश्यक आहे.
ॲरे अशा प्रकारे घोषित केले जातात: int d1; //सामान्य, एक-आयामी int d2; // द्विमितीय दुहेरी d3; //त्रि-आयामी int d5; //पाच-आयामी ॲरे तयार करताना, तुम्ही प्रत्येक स्तराचा आकार स्पष्टपणे निर्दिष्ट करू शकता: d2 = int; // 3 पंक्ती आणि 4 स्तंभांचे मॅट्रिक्स परंतु तुम्ही फक्त पहिल्या स्तराचा आकार निर्दिष्ट करू शकता: int dd2 = int; /* 5 पंक्तींचे मॅट्रिक्स. प्रत्येक ओळीत किती घटक असतील हे अद्याप माहित नाही. */ नंतरच्या प्रकरणात, तुम्ही द्वि-आयामी ॲरे तयार करू शकता, जे प्रत्येक पंक्तीमध्ये घटकांची संख्या भिन्न असेल या वस्तुस्थितीमुळे मॅट्रिक्स होणार नाही. उदाहरणार्थ: for(int i=0; i<5; i++) { dd2[i] = new int; } В результате получим такой вот массив: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Мы могли создать массив явно указав его элементы. Например так: int ddd2 = {{1,2}, {1,2,3,4,5}, {1,2,3}};
या प्रकरणात, तुम्ही दुसऱ्या रांगेत अनुक्रमणिका 4 सह घटक प्रवेश करू शकता ddd2, परंतु जर आपण घटकात प्रवेश केला ddd2 किंवा ddd2- एक त्रुटी उद्भवेल, कारण असे घटक फक्त अस्तित्वात नाहीत. शिवाय, ही त्रुटी प्रोग्रामच्या अंमलबजावणी दरम्यान उद्भवेल (म्हणजे, कंपाइलर ते पाहणार नाही).
सामान्यतः, प्रत्येक पंक्तीमध्ये समान संख्येसह द्वि-आयामी ॲरे वापरल्या जातात, भिन्न काउंटरसह दोन नेस्टेड लूप वापरले जातात (आम्ही 0 ते 9 पर्यंत यादृच्छिक संख्यांसह द्विमितीय ॲरे भरतो आणि मॅट्रिक्सच्या स्वरूपात स्क्रीनवर प्रदर्शित करा: int da = new int; साठी(int i=0; i विभागातील यादृच्छिक पूर्णांकांपैकी प्रत्येकी 5 स्तंभांच्या 8 पंक्तींचा द्विमितीय ॲरे तयार करा. स्क्रीनवर ॲरे प्रदर्शित करा. सेगमेंट [-99;99] मधील प्रत्येकी यादृच्छिक पूर्णांकांपैकी प्रत्येकी 8 स्तंभांसह 5 पंक्तींचा द्विमितीय ॲरे तयार करा. स्क्रीनवर ॲरे प्रदर्शित करा. नंतर, एका वेगळ्या ओळीवर, या ॲरेच्या कमाल घटकाचे मूल्य प्रदर्शित करा (त्याची अनुक्रमणिका काही फरक पडत नाही). सेगमेंट [-5;5] मधील प्रत्येकी यादृच्छिक पूर्णांकांपैकी प्रत्येकी 4 स्तंभांसह 7 पंक्तींचा द्विमितीय ॲरे तयार करा. स्क्रीनवर ॲरे प्रदर्शित करा. घटकांच्या सर्वात मोठ्या निरपेक्ष उत्पादनासह पंक्तीची अनुक्रमणिका निश्चित करा आणि प्रदर्शित करा. जर अशा अनेक ओळी असतील, तर प्रथम आलेल्या इंडेक्सची मुद्रित करा. विभागातील यादृच्छिक पूर्णांकांपैकी प्रत्येकी 7 स्तंभांसह 6 पंक्तींचा द्विमितीय ॲरे तयार करा. स्क्रीनवर ॲरे प्रदर्शित करा. ॲरेचे रूपांतर करा जेणेकरून प्रत्येक पंक्तीमधील सर्वात मोठा घटक प्रथम येईल. या प्रकरणात, ॲरेची रचना बदलली जाऊ शकत नाही, परंतु केवळ एका ओळीत घटकांची पुनर्रचना केली जाऊ शकते. रेषेच्या उर्वरित घटकांचा क्रम महत्त्वाचा नाही (म्हणजे, तुम्ही फक्त एक क्रमपरिवर्तन करू शकता, किंवा तुम्ही प्रत्येक ओळ उतरत्या क्रमाने लावू शकता). रूपांतरित ॲरे स्क्रीनवर प्रदर्शित करा. उन्हाळ्याच्या सुट्टीनंतर विद्यार्थ्यांच्या उरलेल्या ज्ञानाची चाचणी घेण्यासाठी, प्राथमिक शाळेतील शिक्षकांनी प्रत्येक विद्यार्थ्याला गुणाकार तक्त्यातील उदाहरण विचारून प्रत्येक धडा सुरू करण्याचा निर्णय घेतला, परंतु वर्गात 15 लोक आहेत आणि त्यांच्यातील उदाहरणांची पुनरावृत्ती होऊ नये. . शिक्षकांना मदत करण्यासाठी, एक प्रोग्राम लिहा जो गुणाकार सारणीतून 15 यादृच्छिक उदाहरणे प्रदर्शित करेल (2*2 ते 9*9 पर्यंत, कारण 1 आणि 10 ने गुणाकार करणे खूप सोपे आहे). शिवाय, 15 उदाहरणांपैकी एकही पुनरावृत्ती नसावी (उदाहरणे 2*3 आणि 3*2 आणि तत्सम जोड्या पुनरावृत्ती मानल्या पाहिजेत). 2010, अलेक्सी निकोलाविच कोस्टिन. टीआयडीएम विभाग, गणित संकाय, मॉस्को स्टेट पेडॅगॉजिकल युनिव्हर्सिटी. ॲरे हे एक शक्तिशाली साधन आहे जे तुम्हाला मोठ्या प्रमाणात डेटासह कार्य करण्यास अनुमती देते. अर्थात, जर तुम्हाला तुमचा कोड चालू असताना 100 व्हॅल्यू कुठेतरी साठवायची असतील तर त्यासाठी समान व्हेरिएबल्स बनवणे किमान अवास्तव आहे. ॲरे तुम्हाला एका नावाखाली मोठ्या संख्येने मूल्ये संग्रहित करण्यास आणि योग्य निर्देशांक वापरून त्यात प्रवेश करण्यास अनुमती देते. ॲरेची संकल्पना ही नवशिक्यांसाठी जावा शिकण्याचा आधारस्तंभ आहे. शेवटी, ते अनेक डेटा स्ट्रक्चर्ससाठी आधार आहेत. Java हे प्रामुख्याने OOP असल्याने, इतर प्रोग्रामिंग भाषांमधील ॲरेच्या तुलनेत त्यात एक विशिष्ट वैशिष्ट्य आहे - ते ऑब्जेक्ट्स म्हणून दर्शविले जातात. इतर फायद्यांपैकी, हे मेमरी क्लीनअपचे निरीक्षण करण्याची आवश्यकता दूर करते, कारण ते स्वयंचलितपणे मुक्त होते. एक-आयामी ॲरे हा क्लासिक आहे आणि सामान्य नावाशी संबंधित घटकांचा संग्रह आहे, ज्यापैकी प्रत्येक विशिष्ट निर्देशांकाशी संबंधित आहे. ॲरे घोषित करण्याची पद्धत खालील चित्रात दर्शविली आहे. प्रथम, Java ॲरे प्रकार घोषित केला जातो, जो त्यात संग्रहित मूल्यांचा प्रकार परिभाषित करतो. हे काहीही वैध असू शकते नेक्स्टमध्ये ॲरेचे नाव आणि स्क्वेअर ब्रॅकेट्स कंपाइलरला सांगतात की हे व्हेरिएबल ॲरे आहे. कृपया एक महत्त्वाची वस्तुस्थिती लक्षात घ्या. ॲरेच्या बेस प्रकारानंतर किंवा ॲरे नावानंतर ठेवता येते. समान चिन्हानंतर, नवीन ऑपरेटर सूचित केला जातो, जो ॲरेसाठी मेमरीचे वाटप सुरू करतो (ऑब्जेक्ट्सच्या बाबतीत समान), त्यात संग्रहित केलेल्या घटकांचा प्रकार (घोषित बेस प्रकाराशी सुसंगत असणे आवश्यक आहे. पूर्वी), आणि, शेवटी, त्यांची संख्या , चौरस कंसात दर्शविली. Java ॲरेमधील घटकांची संख्या 0 पासून सुरू होते. अशा प्रकारे, या ॲरेमधील पहिल्या घटकाची अनुक्रमणिका 0 असेल आणि सहावा - 5. ॲरेच्या विशिष्ट घटकाचा संदर्भ घेण्यासाठी, उदाहरणार्थ, पाचवा, फक्त नावाच्या पुढे चौरस कंसात ॲरेचे नाव आणि घटकाची अनुक्रमणिका दर्शवा. अशा प्रकारे तुम्ही घटकाला मूल्य नियुक्त करू शकता आणि ते पुनर्प्राप्त करू शकता. तथापि, तुम्ही सावधगिरी बाळगली पाहिजे कारण जर तुम्ही एखादे निर्देशांक पास केले ज्यावर घटक अस्तित्वात नाही, एक त्रुटी येईल. बहुआयामी ॲरे या एक-आयामी ॲरेच्या पंक्ती आहेत ज्या इतर ॲरेच्या घटकांद्वारे संदर्भित आहेत. दुसऱ्या शब्दांत, त्यापैकी सर्वात सोपी द्विमितीय आहेत. त्यांचे उदाहरण वापरून, आपण संकल्पना समजून घेण्याचा प्रयत्न करू. स्पष्टतेसाठी, खालील आकृती द्विमितीय ॲरेच्या संरचनेचे वर्णन करणारी वाक्यरचना आणि आकृती दर्शवते. तुम्ही बघू शकता, वाक्यरचना एक-आयामी ॲरेपेक्षा फार वेगळी नाही. चला रचना पाहू. पहिल्या कंसात आम्ही 5 घटकांसाठी जागा दिली आहे. हे घटक वैयक्तिक ॲरेच्या संदर्भापेक्षा अधिक काही नाहीत. शिवाय, त्या प्रत्येकाचा आकार दुसऱ्या कंसातील संख्येद्वारे निर्धारित केला जातो. खरं तर, गणितातील द्विमितीय ॲरेचे ॲनालॉग मॅट्रिक्स आहेत. कृपया लक्षात घ्या की घटकांव्यतिरिक्त, मेमरीमध्ये एक वेगळे स्थान वाटप केले जाते जेथे ॲरे लांबी मूल्य (लांबी) संग्रहित केले जाते. सामान्यतः, नेस्टेड फॉर लूप वापरून बहुआयामी ॲरेसह कार्य केले जाते. द्विमितीय ॲरे म्हणजे ॲरेचा ॲरे. हे आम्ही आधीच शोधून काढले आहे. पण त्यात असलेल्या ॲरेची लांबी वेगळी असू शकते का? उत्तर होय, ते करू शकतात. हे करण्यासाठी, Java एक विशेष प्रकारे द्विमितीय ॲरे घोषित करण्याची क्षमता प्रदान करते. उदाहरणार्थ, आम्हाला द्वि-आयामी ॲरे तयार करायचे आहेत जे अनुक्रमे 2, 3 आणि 4 लांबीचे तीन एक-आयामी ॲरे संचयित करेल. हे खालीलप्रमाणे घोषित केले आहे: intarr = newint; कृपया लक्षात घ्या की आम्ही दुसऱ्या कंसात संख्या समाविष्ट केलेली नाही. arr मधील ॲरेचा आकार निश्चित करणे याप्रमाणे केले जाते: अनुक्रमणिका 0 वरील घटकामध्ये प्रवेश करून, जो पहिल्या ॲरेकडे निर्देश करतो, आम्ही ते परिमाण 2 चे असल्याचे घोषित करतो. अनुक्रमणिका 1 वरील घटक परिमाण 3 ची ॲरे संग्रहित करेल आणि असेच. हे अगदी सोपे आहे. ॲरे तयार करताना तुम्ही त्यांना थेट आरंभ देखील करू शकता. हे खूपच सोपे आहे. जर्सी नंबर आणि प्लेयरनेम ॲरेच्या घोषणेकडे लक्ष द्या. द्विमितीय ॲरेच्या बाबतीत, ही घोषणा यासारखी दिसते: हे करण्यासाठी, नवीन ऑपरेटरऐवजी, कुरळे ब्रेसेस उघडले जातात, ज्यामध्ये सर्व घटक सूचीबद्ध केले जातात, स्वल्पविरामाने विभक्त केले जातात. या प्रकरणात Java स्वयंचलितपणे त्यांच्यासाठी मेमरी वाटप करते आणि त्यानुसार त्यांना अनुक्रमित करते. Java मधील ॲरे सारख्या संस्थांसोबत काम करण्यासाठी, java.util पॅकेजमध्ये Arrays नावाचा एक विशेष वर्ग आहे, जो अनेक स्थिर पद्धती प्रदान करतो ज्यामुळे त्यांच्यासोबत काम करणे अधिक सोपे होते. मुख्य पद्धतींची यादी खालील आकृतीमध्ये सादर केली आहे. चला काही सर्वात उपयुक्त Java ॲरे पद्धती पाहू: CopyOf (ॲरे, लांबी) - संबंधित लांबीच्या पास केलेल्या ॲरेची प्रत मिळवते. पास केलेली लांबी मूळ ॲरेपेक्षा मोठी असल्यास, सर्व "अतिरिक्त" घटक डीफॉल्ट मूल्याने भरले जातात (साध्या प्रकार असल्यास 0 आणि संदर्भ प्रकार असल्यास शून्य). CopyOfRange(ॲरे, पहिली अनुक्रमणिका, शेवटची अनुक्रमणिका) - चित्रात दाखवलेली नाही, पण एक उपयुक्त पद्धत. हे पास केलेल्या ॲरेचा भाग कॉपी करते, संबंधित निर्देशांकांद्वारे परिभाषित केले जाते, पहिल्यापासून सुरू होते आणि शेवटच्यासह समाप्त होते. क्रमवारी लावा (ॲरे) - ॲरे घटकांची चढत्या क्रमाने क्रमवारी लावते. भरा (ॲरे, मूल्य) - पास केलेले ॲरे योग्य मूल्यासह भरते. BinarySearch (ॲरे, मूल्य) - अनुक्रमणिका मिळवते ज्यावर संबंधित मूल्यासह घटक पास केलेल्या क्रमवारीत ॲरेमध्ये स्थित आहे. असा कोणताही घटक नसल्यास, ऋण संख्या दिली जाते. पद्धती स्थिर असल्याने, त्यांना कॉल करण्यासाठी Arrays वर्गाचे उदाहरण तयार करण्याची आवश्यकता नाही. त्यांना थेट त्यावरून कॉल केले जाते: Arrays.sort(arr). आम्ही ॲरेच्या संदर्भात सर्वात महत्त्वाच्या पैलूंचा समावेश केला आहे आणि जे नवशिक्यांसाठी Java शिकायला सुरुवात करत आहेत, त्यांच्यासाठी ॲरे म्हणून अशा घटकाची मूलभूत माहिती आणि त्यासोबत काम करण्याच्या मूलभूत तंत्रांसाठी हे पुरेसे असेल. अर्थात, सराव तुम्हाला हे साधन कसे कार्य करते याबद्दल अधिक समज देईल. त्यामुळे वेगवेगळ्या प्रकारे ॲरेज हाताळण्यासाठी काही व्यायाम करण्यासाठी वेळ काढा. Array Java सहाय्यक वर्ग आधीच "लढाऊ" परिस्थितीत वापरला जातो, म्हणून प्रथम ॲरेसह सर्व मूलभूत ऑपरेशन्स व्यक्तिचलितपणे कसे करावे हे शिकण्याची शिफारस केली जाते. आपण एक-आयामी ॲरे कसे तयार करायचे ते शिकलो. त्याचप्रमाणे, Java मध्ये तुम्ही 2D, 3D, 4D... दुसऱ्या शब्दांत, बहुआयामी ॲरे. Java मधील बहुआयामी ॲरे मूलत: ॲरेचा ॲरे आहे. या प्रकारच्या ॲरेच्या वापराचे एक लोकप्रिय उदाहरण म्हणजे मॅट्रिक्स, ज्याच्या प्रतिनिधित्वासाठी द्विमितीय ॲरे वापरले जातात. तर, मॅट्रिक्स म्हणजे काय आणि Java मध्ये द्विमितीय ॲरे वापरून त्याचे प्रतिनिधित्व कसे करायचे. मॅट्रिक्स एक आयताकृती सारणी आहे ज्यामध्ये त्याचे घटक स्थित आहेत त्या छेदनबिंदूवर पंक्ती आणि स्तंभ असतात. मॅट्रिक्सच्या पंक्ती आणि स्तंभांची संख्या त्याचा आकार निर्धारित करते. मॅट्रिक्स आकाराचे सामान्य दृश्य मी x n(मी-ओळींची संख्या, n —स्तंभांची संख्या) ,
पुढीलप्रमाणे: मॅट्रिक्सच्या प्रत्येक घटकाची स्वतःची अनुक्रमणिका असते, जिथे पहिला अंक पंक्ती क्रमांक दर्शवतो ज्यावर घटक स्थित आहे आणि दुसरा अंक स्तंभ क्रमांक दर्शवतो. चला विशिष्ट मॅट्रिक्सची उदाहरणे पाहू आणि Java वापरून तयार करू. मॅट्रिक्स ए
2 बाय 3 (2 पंक्ती, 3 स्तंभ) चे परिमाण आहे. चला या परिमाणाचा द्विमितीय ॲरे तयार करूया: इंट मॅट्रिक्सए; matrixA = नवीन इंट; आम्ही पूर्णांकांची द्विमितीय ॲरे घोषित केली (कारण या प्रकरणातील मॅट्रिक्समध्ये पूर्णांक आहेत) आणि त्यासाठी राखीव मेमरी. हे करण्यासाठी, आम्ही 2 निर्देशांक वापरले: पहिला निर्देशांक पंक्ती आणि त्याचा आकार परिभाषित करतो, दुसरा निर्देशांक स्तंभ आणि त्याचा आकार परिभाषित करतो. द्विमितीय ॲरेच्या घटकांमध्ये प्रवेश करण्यासाठी, तुम्ही 2 अनुक्रमणिका वापरणे आवश्यक आहे: पंक्तीसाठी पहिला, स्तंभासाठी दुसरा. एक-आयामी ॲरे प्रमाणे, निर्देशांक देखील शून्य पासून सुरू होतात. म्हणून, सारणीतील पंक्ती आणि स्तंभांची संख्या 0 पासून सुरू होते. मॅट्रिक्सए = 1; matrixA = -2; matrixA = 3; matrixA = 4; matrixA = 1; matrixA = 7; कन्सोलवर मॅट्रिक्स प्रदर्शित करण्यासाठी, तुम्हाला दोन लूप वापरून सर्व घटकांमधून जाण्याची आवश्यकता आहे. ॲरेच्या घटकांमधून जात असताना चक्रांची संख्या त्याच्या परिमाणाइतकी असते. आमच्या बाबतीत, पहिला लूप पंक्तीसह चालविला जातो, दुसरा - स्तंभांद्वारे. साठी (int i = 0; i< 2; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(matrixA[i][j] + "\t");
}
System.out.println();
} म्हणजेच, आम्ही प्रथम पहिल्या ओळीचे सर्व घटक प्रदर्शित करतो, त्यांना "\t" या टॅब वर्णाने वेगळे करतो, ओळ खंडित करतो आणि दुसऱ्या ओळीचे सर्व घटक प्रदर्शित करतो. मॅट्रिक्ससाठी पूर्ण कोड एपुढीलप्रमाणे: पब्लिक क्लास मॅट्रिक्स ( सार्वजनिक स्थिर शून्य मुख्य(स्ट्रिंग आर्ग्स) ( int matrixA; matrixA = new int; matrixA = 1; matrixA = -2; matrixA = 3; matrixA = 4; matrixA = 1; matrixA = 7; साठी (int i = 0;< 2; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(matrixA[i][j] + "\t");
}
System.out.println();
}
}
} मॅट्रिक्ससाठी बीचला फायदा घेऊया सरलीकृत आरंभ पद्धत- घोषणेच्या वेळी. एक-आयामी ॲरेसह सादृश्यतेनुसार. इंट मॅट्रिक्सबी = ( (-9,1,0), (4,1,1), (-2,2,-1)); ॲरेमधील प्रत्येक पंक्ती कुरळे ब्रेसेसच्या जोडीमध्ये बंद केलेली आणि स्वल्पविरामाने विभक्त केलेली असणे आवश्यक आहे. मॅट्रिक्ससाठी पूर्ण कोड बी: पब्लिक क्लास मॅट्रिक्स ( सार्वजनिक स्थिर शून्य मुख्य(स्ट्रिंग आर्ग्स) ( इंट मॅट्रिक्सबी = ( (-9,1,0), (4,1,1), (-2,2,-1)); साठी (इंट i = 0;< 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(matrixB[i][j] + "\t");
}
System.out.println();
}
}
} चला विचार करूया लूपमध्ये आरंभ करणेउदाहरण म्हणून गुणाकार सारणी वापरून द्विमितीय ॲरेसाठी. पब्लिक क्लास मल्ट ( पब्लिक स्टॅटिक व्हॉइड मेन(स्ट्रिंग आर्ग्स) ( // द्विमितीय ॲरे तयार करा 10 बाय 10 int multiplyTab = new int; // (int i = 0; i) साठी पहिल्या डायमेंशनमधून लूप< 10; i++) {
// цикл по второй размерности
for (int j = 0; j < 10; j++) {
//инициализация элементов массива
multiplyTab[i][j] = (i+1)*(j+1);
//вывод элементов массива
System.out.print(multiplyTab[i][j] + "\t");
}
System.out.println();
}
}
} येथे, गुणाकार सारणीच्या मूल्यांसह घटकांचे आरंभीकरण त्यांच्या आउटपुटसह एका चक्रात कन्सोलमध्ये एकत्र केले जाते. बहुआयामी ॲरे Java मध्ये अशाच प्रकारे तयार केले जातात. चौरस कंसांची संख्या परिमाण दर्शवते. int a = new int;// द्विमितीय ॲरे int b = new int;// त्रिमितीय ॲरे int c = new int;// चार-आयामी ॲरे // इ. तथापि, सुरुवातीला सर्व स्तरांवर आकार निर्दिष्ट करणे आवश्यक नाही, आपण केवळ प्रथम स्तरावर आकार निर्दिष्ट करू शकता. इंट a1 = नवीन इंट; // 5 पंक्तीसह द्विमितीय ॲरे या प्रकरणात, प्रत्येक ओळीत किती घटक असतील हे अद्याप माहित नाही, हे नंतर निश्चित केले जाऊ शकते आणि ॲरेमध्ये प्रत्येक ओळीत भिन्न संख्येने घटक असू शकतात, म्हणजेच ते असू शकते. असममित. ॲरे a1 साठी प्रत्येक ओळीतील घटकांची संख्या ठरवू A1 = नवीन इंट ; a1 = नवीन इंट; a1 = नवीन इंट; a1 = नवीन इंट; a1 = नवीन इंट; परिणामी, स्क्रीनवर प्रदर्शित झाल्यावर, साठी(int i = 0; i ॲरे यासारखे दिसेल: 0 ॲरे तयार केल्यावर, त्याचे घटक आपोआप शून्यावर सुरू होतात, म्हणून या उदाहरणात शून्य प्रदर्शित केले जातात. 19 उत्तरे तुम्ही ॲरे डिक्लेरेशन किंवा ॲरे लिटरल वापरू शकता (परंतु जेव्हा तुम्ही व्हेरिएबल ताबडतोब घोषित करता आणि त्यावर प्रभाव टाकता; ॲरे लिटरल ॲरे पुन्हा नियुक्त करण्यासाठी वापरले जाऊ शकत नाही). आदिम प्रकारांसाठी: इंट myIntArray = new int; + myIntArray = (1,2,3); int myIntArray = नवीन int(1,2,3); स्ट्रिंग सारख्या वर्गांसाठी ते समान आहे: स्ट्रिंग myStringArray = नवीन स्ट्रिंग; स्ट्रिंग myStringArray = ("a","b","c"); स्ट्रिंग myStringArray = नवीन स्ट्रिंग("a","b","c"); इनिशिएलायझेशनची तिसरी पद्धत उपयोगी असते जेव्हा तुम्ही प्रथम ॲरे घोषित करता आणि नंतर ते सुरू करता. इथे कलाकारांची गरज आहे. स्ट्रिंग myStringArray; myStringArray = नवीन स्ट्रिंग("a","b","c"); ॲरेचे दोन प्रकार आहेत. डीफॉल्ट मूल्य वाक्यरचना: int num = new int; किंवा (कमी प्राधान्य) int num = new int; निर्दिष्ट मूल्यांसह वाक्यरचना (व्हेरिएबल/फील्ड इनिशिएलायझेशन): इंट संख्या = (1,2,3,4,5); किंवा (कमी प्राधान्य) इंट संख्या = (1, 2, 3, 4, 5); नोंद. सोयीसाठी, int num ला प्राधान्य दिले जाते कारण ते स्पष्टपणे नमूद करते की तुम्ही येथे ॲरेबद्दल बोलत आहात. अन्यथा फरक नाही. अजिबात नाही. int num = new int; int num = new int; इंट संख्या =( (1,2), (1,2), (1,2), (1,2), (1,2) ); म्हणून येथे आम्ही स्तंभ स्पष्टपणे परिभाषित करतो. इंट संख्या =( (1), (1,2), (1,2,3,4,5), (1,2), (1,2,3) ); साठी (int a: num) ( साठी (int i: a) ( System.out.println(i); ) ) प्रकार variableName = new Type; प्रकार variableName = (स्वल्पविराम-डिलिमिटेड मूल्ये); प्रकार variableName = new Type; प्रकार variableName = (स्वल्पविराम-डिलिमिटेड मूल्ये); देखील वैध आहे, परंतु मी प्रकारानंतर कंस पसंत करतो कारण व्हेरिएबलचा प्रकार प्रत्यक्षात ॲरे आहे हे पाहणे सोपे आहे. खालील ॲरे डिक्लेरेशन दाखवते, परंतु ॲरे सुरू केलेले नाही: इंट myIntArray = new int; खाली घोषणा तसेच ॲरेचे आरंभीकरण आहे: + myIntArray = (1,2,3); आता खालील घोषणा तसेच ॲरेचे आरंभिकरण देखील दर्शवते: इंट myIntArray = नवीन int(1,2,3); परंतु हा तिसरा ॲरे-ऑब्जेक्टचा निनावी निर्मिती गुणधर्म दाखवतो, जो संदर्भ चल "myIntArray" द्वारे दर्शविला जातो, म्हणून जर आपण फक्त "new int(1,2,3);" असे लिहितो. मग तो एक अनामित ॲरे ऑब्जेक्ट असू शकतो. आम्ही फक्त लिहिल्यास: + myIntArray; ही ॲरे घोषणा नाही, परंतु खालील विधान खालील अभिव्यक्ती पूर्ण करते: MyIntArray=new int; तुम्ही प्रत्येक भाग समजून घेतल्यास मला ते उपयुक्त वाटते: प्रकार नाव = नवीन प्रकार; प्रकार हा नाव नावाच्या व्हेरिएबलचा प्रकार आहे ("नाव" ला ओळखकर्ता म्हणतात). शाब्दिक "प्रकार" हा बेस प्रकार आहे आणि कंस म्हणजे तो त्या बेसचा ॲरे प्रकार आहे. ॲरे प्रकार, त्या बदल्यात, त्यांचे स्वतःचे असतात, जे तुम्हाला प्रकार प्रकाराचे बहुआयामी ॲरे तयार करण्यास अनुमती देतात ( ॲरे प्रकार प्रकार ). नवीन कीवर्ड नवीन ॲरेसाठी मेमरीच्या वाटपाचा संदर्भ देतो. ब्रॅकेटमधील संख्या नवीन ॲरे किती मोठी असेल आणि किती मेमरी वाटप केली जाईल हे सांगते. उदाहरणार्थ, जर Java ला माहित असेल की अंतर्निहित प्रकार 32 बाइट्स आहे आणि तुम्हाला आकार 5 चा ॲरे हवा असेल, तर त्याला अंतर्गत 32 * 5 = 160 बाइट्स वाटप करणे आवश्यक आहे. तुम्ही आधीच अस्तित्वात असलेल्या मूल्यांसह ॲरे देखील तयार करू शकता, जसे की इंट नेम = (1, 2, 3, 4, 5); जे केवळ रिक्त जागाच निर्माण करत नाही तर या मूल्यांनी भरते. Java सांगू शकते की आदिम पूर्णांक आहेत आणि त्यापैकी 5 आहेत, त्यामुळे ॲरेचा आकार स्पष्टपणे निर्धारित केला जाऊ शकतो. तसेच, जर तुम्हाला काहीतरी अधिक डायनॅमिक हवे असेल तर सूची इंटरफेस आहे. हे कार्य करणार नाही, परंतु अधिक लवचिक आहे: यादी ॲरे तयार करण्याचे दोन मुख्य मार्ग आहेत: हे, रिक्त ॲरेसाठी: इंट ॲरे = नवीन इंट[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) ); सर्वसाधारणपणे तुम्ही एम डायमेंशनल असलेले ॲरे तयार करू शकता इंट .. ॲरे = // ^ एम वेळा कंस (..( // ^ एम वेळा ( कंस // हा ॲरे आहे.. // ^ एम वेळा ))..) // ^ एम वेळा ) कंस ; हे लक्षात घेण्यासारखे आहे की मितीय ॲरे M तयार करणे स्पेसच्या दृष्टीकोनातून महाग आहे. कारण जेव्हा तुम्ही सर्व परिमाणांमध्ये N सह M एक ॲरे तयार करता तेव्हा ॲरेचा एकूण आकार N^M पेक्षा मोठा असतो, कारण प्रत्येक ॲरेला लिंक असते आणि M डायमेंशनमध्ये (M -1)-आयामी ॲरे असते दुव्यांचे. एकूण आकार खालीलप्रमाणे आहे शेवटचे अपडेट: 11/09/2018 ॲरे समान प्रकारच्या मूल्यांचा संच दर्शवतो. ॲरे घोषित करणे हे नियमित व्हेरिएबल घोषित करण्यासारखे आहे जे एकल मूल्य संचयित करते आणि ॲरे घोषित करण्याचे दोन मार्ग आहेत: data_type array_name; // एकतर data_type array_name; उदाहरणार्थ, संख्यांचा ॲरे परिभाषित करू: इंट संख्या; int nums2; ॲरे घोषित केल्यानंतर, आम्ही ते सुरू करू शकतो: इंट संख्या; nums = नवीन इंट; // 4 संख्यांचा ॲरे खालील बांधकाम वापरून ॲरे तयार केला जातो: new data_type[घटकांची संख्या] , जिथे new हा एक कीवर्ड आहे जो कंसात निर्दिष्ट केलेल्या घटकांच्या संख्येसाठी मेमरी वाटप करतो. उदाहरणार्थ, nums = new int; - ही अभिव्यक्ती चार इंट घटकांची ॲरे तयार करते आणि प्रत्येक घटकाचे डीफॉल्ट मूल्य 0 असेल. ॲरे घोषित करताना तुम्ही ताबडतोब प्रारंभ देखील करू शकता: इंट संख्या = नवीन इंट; // 4 संख्यांचा ॲरे int nums2 = new int; // 5 संख्यांचा ॲरे अशा आरंभीकरणासह, सर्व ॲरे घटकांना डीफॉल्ट मूल्य असते. अंकीय प्रकारांसाठी (कॅर प्रकारासह) ही संख्या 0 आहे, बुलियन प्रकारासाठी हे असत्य आहे आणि इतर वस्तूंसाठी हे शून्य आहे. उदाहरणार्थ, इंट प्रकारासाठी डीफॉल्ट मूल्य 0 आहे, म्हणून वर परिभाषित केलेल्या संख्या ॲरेमध्ये चार शून्य असतील. तथापि, तुम्ही ॲरे तयार करता तेव्हा त्याच्या घटकांसाठी विशिष्ट मूल्ये देखील सेट करू शकता: // या दोन पद्धती समतुल्य आहेत int nums = new int ( 1, 2, 3, 5 ); int nums2 = ( 1, 2, 3, 5); हे लक्षात घेण्यासारखे आहे की या प्रकरणात चौरस कंस ॲरेचा आकार दर्शवत नाहीत, कारण ते कुरळे ब्रेसेसमधील घटकांच्या संख्येनुसार मोजले जाते. ॲरे तयार केल्यावर, आपण इंडेक्सद्वारे त्यातील कोणत्याही घटकांमध्ये प्रवेश करू शकतो, जो ॲरे व्हेरिएबलच्या नावानंतर चौरस कंसात पास केला जातो: Int nums = new int; // ॲरे घटकांची मूल्ये सेट करा संख्या = 1; संख्या = 2; संख्या = 4; संख्या = 100; // ॲरे System.out.println(nums) च्या तिसऱ्या घटकाचे मूल्य मिळवा; // 4 ॲरे घटकांची अनुक्रमणिका 0 पासून सुरू होते, त्यामुळे या प्रकरणात, ॲरेमधील चौथ्या घटकामध्ये प्रवेश करण्यासाठी, आम्हाला अंक अभिव्यक्ती वापरण्याची आवश्यकता आहे. आणि आमची ॲरे फक्त 4 घटकांसाठी परिभाषित केली असल्याने, आम्ही प्रवेश करू शकत नाही, उदाहरणार्थ, सहावा घटक: nums = 5; . आम्ही असे करण्याचा प्रयत्न केल्यास, आम्हाला एक त्रुटी मिळेल. ॲरेची सर्वात महत्त्वाची गुणधर्म म्हणजे लांबी गुणधर्म, जी ॲरेची लांबी मिळवते, म्हणजेच त्याच्या घटकांची संख्या: इंट संख्या = (1, 2, 3, 4, 5); int length = nums.length; // 5 शेवटची अनुक्रमणिका अज्ञात असणे असामान्य नाही आणि ॲरेचा शेवटचा घटक मिळविण्यासाठी, आम्ही ही गुणधर्म वापरू शकतो: इंट लास्ट = nums; पूर्वी, आम्ही एक-आयामी ॲरे पाहिल्या, ज्यांना एकाच प्रकारच्या मूल्यांची साखळी किंवा स्ट्रिंग म्हणून दर्शविले जाऊ शकते. परंतु एक-आयामी ॲरे व्यतिरिक्त, बहु-आयामी देखील आहेत. सर्वात प्रसिद्ध बहुआयामी ॲरे ही द्विमितीय ॲरे दर्शविणारी सारणी आहे: Int nums1 = नवीन int ( 0, 1, 2, 3, 4, 5); int nums2 = ( ( 0, 1, 2), ( 3, 4, 5 ) ); दृश्यमानपणे, दोन्ही ॲरे खालीलप्रमाणे दर्शविले जाऊ शकतात: nums2 ॲरे द्विमितीय असल्याने, ते एक साधे सारणी आहे. हे असे देखील तयार केले जाऊ शकते: int nums2 = new int; . चौरस कंसांची संख्या ॲरेचा आकार दर्शवते. आणि कंसातील संख्या पंक्ती आणि स्तंभांची संख्या दर्शवतात. आणि तसेच, निर्देशांक वापरून, आम्ही प्रोग्राममध्ये ॲरे घटक वापरू शकतो: // दुसऱ्या पंक्तीच्या पहिल्या स्तंभाचा घटक सेट करा nums2=44; System.out.println(nums2); त्रिमितीय ॲरे घोषणा यासारखे दिसू शकते: Int nums3 = new int; बहुआयामी ॲरे "जॅग्ड ॲरे" म्हणून देखील दर्शविले जाऊ शकतात. वरील उदाहरणात, द्विमितीय ॲरेमध्ये 3 पंक्ती आणि तीन स्तंभ आहेत, म्हणून आमच्याकडे एक सपाट टेबल आहे. परंतु आम्ही द्वि-आयामी ॲरेमधील प्रत्येक घटकाला वेगवेगळ्या घटकांसह स्वतंत्र ॲरे नियुक्त करू शकतो: Int nums = new int; nums = नवीन इंट; nums = नवीन इंट; nums = नवीन इंट; फॉर लूपची एक विशेष आवृत्ती घटकांच्या संचातील घटकांवर पुनरावृत्ती करण्यासाठी डिझाइन केलेली आहे, जसे की ॲरे आणि संग्रह. हे इतर प्रोग्रामिंग भाषांमध्ये आढळणाऱ्या फोरच लूपसारखेच आहे. त्याची औपचारिक घोषणा: साठी (data_type variable_name: कंटेनर)( // क्रिया) उदाहरणार्थ: इंट ॲरे = नवीन इंट ( 1, 2, 3, 4, 5); साठी (int i: array)( System.out.println(i); ) या प्रकरणात, कंटेनर हा int प्रकारातील डेटाचा ॲरे आहे. नंतर int चे व्हेरिएबल घोषित केले जाते यासाठीच्या नियमित आवृत्तीसह समान गोष्ट केली जाऊ शकते: इंट ॲरे = नवीन इंट ( 1, 2, 3, 4, 5); साठी (int i = 0; i< array.length; i++){
System.out.println(array[i]);
}
त्याच वेळी, फॉर लूपची ही आवृत्ती for (int i: array) पेक्षा अधिक लवचिक आहे. विशेषतः, या आवृत्तीमध्ये आम्ही घटक बदलू शकतो: इंट ॲरे = नवीन इंट ( 1, 2, 3, 4, 5); साठी (int i=0; i प्रथम, पंक्तींवर पुनरावृत्ती करण्यासाठी एक लूप तयार केला जातो आणि नंतर पहिल्या लूपमध्ये, विशिष्ट पंक्तीच्या स्तंभांवर पुनरावृत्ती करण्यासाठी एक अंतर्गत लूप तयार केला जातो. अशाच प्रकारे, तुम्ही त्रिमितीय ॲरे आणि सेटवर मोठ्या प्रमाणात परिमाणांसह पुनरावृत्ती करू शकता.कार्ये
एक-आयामी ॲरे तयार करणे आणि हाताळणे
Java मधील बहुआयामी ॲरे
अनियमित ॲरे
वैकल्पिक जावा ॲरे घोषणा वाक्यरचना
हेल्पर क्लास ॲरे
निष्कर्ष
Java मध्ये मॅट्रिक्स आणि द्विमितीय ॲरे
बहुआयामी आणि असममित ॲरे.
निश्चित-लांबीचे ॲरे तयार करण्याची उदाहरणे:
0 0
0 0 0
0 0 0 0
0 0 0 0 0Java मधील बहुआयामी ॲरेवरील व्यायाम:
एक मितीय ॲरे
बहुआयामी ॲरे
घोषणा
int num = नवीन int; आरंभ करणे
संख्या = 1; संख्या = 2; संख्या = 1; संख्या = 2; संख्या = 1; संख्या = 2; संख्या = 1; संख्या = 2; संख्या = 1; संख्या = 2; रॅग्ड ॲरे (किंवा नॉन-आयताकृती ॲरे)
int num = नवीन int; संख्या = नवीन इंट; संख्या = नवीन इंट; संख्या = नवीन इंट; संख्या = नवीन इंट;
दुसरा मार्ग:प्रवेश करण्यासाठी:
साठी (int i=0; i<(num.length); i++) {
for (int j=0;jबहुआयामी ॲरे
ॲरे लांबी
बहुआयामी ॲरे
एक-आयामी ॲरे संख्या1
द्विमितीय ॲरे संख्या2
दागदार अरे
प्रत्येकासाठी
बहुआयामी ॲरेद्वारे लूपिंग
int nums = new int ( (1, 2, 3), (4, 5, 6), (7, 8, 9) ); साठी (int i = 0; i< nums.length; i++){
for(int j=0; j < nums[i].length; j++){
System.out.printf("%d ", nums[i][j]);
}
System.out.println();
}
