नमस्ते! पहले आपके प्रशिक्षण में, हमने एकल वस्तुओं (और आदिम प्रकार) के साथ काम किया है। लेकिन क्या होगा अगर हमें केवल एक के बजाय वस्तुओं के पूरे समूह के साथ काम करने की ज़रूरत है? उदाहरण के लिए, मान लें कि हम अपनी कंपनी के सभी कर्मचारियों के जन्मदिन की सूची बनाना चाहते हैं। इसमें निम्नानुसार स्वरूपित 30 स्ट्रिंग्स होनी चाहिए: "सारा हफ़मैन, 25 जनवरी" हमें एक विशेष डेटा संरचना से लाभ होगा जिसे एक सरणी कहा जाता है । यदि हम किसी सरणी की वास्तविक वस्तु से तुलना करते हैं, तो यह सुरक्षा जमा बॉक्स के साथ बैंक वॉल्ट के समान है: एक सरणी में "बक्से" भी होते हैं। आप प्रत्येक बॉक्स में कुछ (एक तत्व) डाल सकते हैं। किसी तत्व तक पहुँचने के लिए, आपको उसका बॉक्स नंबर (इंडेक्स) जानना होगा। इस प्रकार एक सरणी बनाई जाती है:
public class Main {
public static void main(String[] args) {
String [] birthdays = new String[10];
}
}
यहां हम एक ऐरे बनाते हैं जिसमें 10 तत्व होते हैं। आप सरणी की कुछ विशेषताओं को तुरंत नोट कर सकते हैं:
यह एक अच्छी तरह से परिभाषित डेटा प्रकार के तत्वों को संग्रहीत करता है । यदि हम एक स्ट्रिंग ऐरे बनाते हैं, तो हम इसमें कुछ और स्टोर नहीं कर सकते हैं। डेटा प्रकार निर्दिष्ट किया जाता है जब सरणी बनाई जाती है । यह वह जगह है जहां यह एक सुरक्षा जमा बॉक्स से अलग होता है (जिसमें ग्राहक जो चाहता है उसे स्टोर कर सकता है)।
सरणी बनाते समय इसका आकार निर्दिष्ट होना चाहिए । आप इसे बाद में इंगित नहीं कर सकते हैं या सरणी बनने के बाद इसका आकार नहीं बदल सकते हैं ।
तथ्य यह है कि हम एक सरणी बना रहे हैं अभिव्यक्ति के दोनों किनारों पर वर्ग कोष्ठक द्वारा इंगित किया गया है। उन्हें संदर्भ चर के नाम से पहले या बाद में निर्दिष्ट किया जा सकता है। किसी भी तरह से काम करेगा:
String [] birthdays = new String[10];
String birthdays [] = new String[10];
यदि आप किसी सरणी में कुछ लिखना चाहते हैं, तो आपको उस बॉक्स की अनुक्रमणिका निर्दिष्ट करने की आवश्यकता है जहां मान लिखा जाएगा। एक सरणी में बक्से 0 से शुरू होते हैं। प्रोग्रामिंग में शून्य से गिनती शुरू करना एक बहुत ही सामान्य अभ्यास है। जितनी जल्दी आपको इसकी आदत हो जाए, उतना ही बेहतर :) इसका मतलब है, अगर आप पहले बॉक्स में कुछ मूल्य रखना चाहते हैं , तो आप यह करते हैं:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
}
}
अब जाना का जन्मदिन हमारे कर्मचारी जन्मदिन की पहली सेल में संग्रहीत है: आप इसी तरह से अन्य मान जोड़ सकते हैं:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[7] = "Rosie Mills, January 3";
}
}
ध्यान दें कि हमने रोजी के जन्मदिन को आठवें बॉक्स में जोड़ा है (आप भूल गए हैं कि बॉक्स नंबर 7 आठवां बॉक्स क्यों है, है ना?) । आप देख सकते हैं कि हमने अन्य सभी सेल नहीं भरे हैं। हमें क्रम में किसी सरणी में मान लिखने की आवश्यकता नहीं है। ऐसी कोई आवश्यकता नहीं है। बेशक, तत्वों को क्रम में लिखने से यह ट्रैक करना बहुत आसान हो जाता है कि कितने बॉक्स खाली हैं और कितने कब्जे में हैं, और यह सरणी को "छेद" होने से रोकता है। यदि आप किसी एक बॉक्स की सामग्री प्राप्त करना चाहते हैं, तो (ठीक सुरक्षा जमा बॉक्स की तरह) आपको इसकी संख्या जानने की आवश्यकता है। इसे इस प्रकार किया जाता है:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[7] = "Rosie Mills, January 3";
String rosieBirthday = birthdays[7];
System.out.println(rosieBirthday);
}
}
कंसोल आउटपुट: रोजी मिल्स, 3 जनवरी हमने एक वेरिएबल बनाया और कंपाइलर को बताया: " बर्थडेString एरे में इंडेक्स 7 के साथ बॉक्स को ढूंढें , और वेरिएबल रोजीबर्थडे को उसमें मौजूद वैल्यू असाइन करें "। और इसने ठीक ऐसा ही किया। सरणी के साथ काम करते समय, हम एक विशेष संपत्ति का उपयोग करके आसानी से उनकी लंबाई पा सकते हैं: लंबाई । String
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[7] = "Rosie Mills, January 3";
int birthdaysLength = birthdays.length;
System.out.println(birthdaysLength);
}
}
कंसोल आउटपुट: 10 नोट: lengthसंपत्ति सरणी आकार को संग्रहीत करती है, न कि उन बॉक्सों की संख्या जो भरे हुए हैं। हमारी सरणी केवल 3 मान संग्रहीत करती है, लेकिन जब हमने इसे बनाया था तो हमने इसका आकार 10 बताया था। और यह ठीक वही मान है जो lengthफ़ील्ड लौटाता है। यह काम क्यों आएगा? ठीक है, मान लीजिए कि आप सभी जन्मदिनों की एक सूची प्रदर्शित करना चाहते हैं (यह सत्यापित करने के लिए कि कोई भी भूला नहीं गया है)। आप इसे एक साधारण पाश में कर सकते हैं:
public class Main {
public static void main(String[] args) {
String birthdays [] = new String[10];
birthdays[0] = "Jana Russell, March 12";
birthdays[1] = "Landon Chan, May 18";
birthdays[2] = "Jeremiah Leonard, July 12";
birthdays [3] = "Kenny Russo, September 7";
birthdays[4] = "Tommie Barnes, November 9";
birthdays [5] = "Roman Baranov, August 14";
birthdays [6] = "Chanice Andersen, April 1";
birthdays[7] = "Rosie Mills, January 3";
birthdays [8] = "Keenan West, October 19";
birthdays [9] = "Abraham McArthur, May 3";
for (int i = 0; i < birthdays.length; i++) {
System.out.println(birthdays[i]);
}
}
}
लूप में, हम वेरिएबल की घोषणा करते हैं i, जिसे शून्य से प्रारंभ किया जाता है। प्रत्येक पास पर, हम अपने सरणी से इंडेक्स i वाला तत्व प्राप्त करते हैं और उसका मान प्रदर्शित करते हैं। लूप 10 पुनरावृत्ति करेगा, और मैं 0 से 9 तक बढ़ूंगा- और संख्याएं हमारे सरणी के तत्वों के सूचक होंगे! नतीजतन, हम जन्मदिन [0] से जन्मदिन [9] तक सभी मूल्यों को प्रदर्शित करेंगे वास्तव में, एक और तरीका है जिससे आप एक सरणी बना सकते हैं। उदाहरण के लिए, आप intइस तरह की एक सरणी बना सकते हैं:
public class Main {
public static void main(String[] args) {
int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
}
}
इस तकनीक को "शॉर्टकट इनिशियलाइज़ेशन" कहा जाता है। यह काफी सुविधाजनक है, क्योंकि हम एक साथ एक सरणी बनाते हैं और इसे मूल्यों से भरते हैं। हमें सरणी आकार को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है: शॉर्टकट आरंभीकरण के साथ, lengthफ़ील्ड स्वचालित रूप से सेट हो जाती है।
public class Main {
public static void main(String[] args) {
int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
System.out.println(numbers.length);
}
}
कंसोल आउटपुट: 9 अब, मेमोरी में सरणियों को कैसे संग्रहीत किया जाता है, इसके बारे में थोड़ा सा। मान लीजिए कि हमारे पास तीन Catवस्तुओं की एक सरणी है:
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public static void main(String[] args) {
Cat[] cats = new Cat[3];
cats[0] = new Cat("Thomas");
cats[1] = new Cat("Behemoth");
cats[2] = new Cat("Lionel Messi");
}
}
यहां आपको कुछ बातें समझने की जरूरत है:
आदिम के मामले में, एक सरणी विशिष्ट मानों (जैसे ints) का एक सेट संग्रहीत करती है। वस्तुओं के मामले में, एक सरणी संदर्भों का एक सेट संग्रहीत करती है ।
सरणी catsमें तीन तत्व होते हैं, जिनमें से प्रत्येक एक वस्तु का संदर्भ है। Catप्रत्येक संदर्भ स्मृति पते को इंगित करता है जहां संबंधित वस्तु संग्रहीत होती है।
स्मृति में एकल ब्लॉक में ऐरे तत्वों की व्यवस्था की जाती है। यह उन्हें जल्दी और कुशलता से एक्सेस करने की अनुमति देने के लिए किया जाता है।
इस प्रकार, catsमेमोरी के ब्लॉक को संदर्भित करता है जहां सभी ऑब्जेक्ट (सरणी तत्व) संग्रहीत होते हैं। Cats[0]इस ब्लॉक के भीतर एक विशिष्ट पते का संदर्भ देता है। यह समझना महत्वपूर्ण है कि एक सरणी केवल वस्तुओं को संग्रहीत नहीं करती है: यह स्वयं एक वस्तु है। यह हमें इस सवाल की ओर ले जाता है कि क्या हम न केवल स्ट्रिंग्स या संख्याओं की सरणी बना सकते हैं, बल्कि सरणी के सरणी भी बना सकते हैं । और जवाब है हां, हम कर सकते हैं! एक सरणी अन्य सरणियों सहित किसी भी वस्तु को संग्रहीत कर सकती है। ऐसी सरणी को द्वि-आयामी कहा जाता है । यदि हम इसे दृश्य रूप में प्रस्तुत करें, तो यह एक साधारण तालिका के समान ही होगा। मान लीजिए, हम 3 सरणियों की एक सरणी बनाना चाहते हैं जो प्रत्येक 10 intएस को स्टोर कर सके। यह ऐसा दिखेगा:
प्रत्येक पंक्ति एक intसरणी का प्रतिनिधित्व करती है। पहली सरणी में 1 से 10 तक की संख्याएँ होती हैं, दूसरी सरणी - -1 से -10 तक, और तीसरी - यादृच्छिक संख्याओं का एक समूह। इनमें से प्रत्येक सरणी हमारे द्वि-आयामी सरणी के बक्से में संग्रहीत है। कोड में, द्वि-आयामी सरणी का प्रारंभ इस तरह दिखता है:
public static void main(String[] args) {
Cat[][] cats = new Cat[3][5];
}
हमारी द्वि-आयामी सरणी बिल्लियाँ प्रत्येक सरणी में 5 बक्से के साथ 3 सरणियाँ संग्रहीत करती हैं । यदि हम किसी वस्तु को दूसरे सरणी के तीसरे बॉक्स में रखना चाहते हैं , तो हम यह करेंगे:
public static void main(String[] args) {
Cat[][] cats = new Cat[3][5];
cats[1][2] = new Cat("Fluffy");
}
[1]दूसरी सरणी को इंगित करता है, और [2]उस सरणी के तीसरे बॉक्स को इंगित करता है। क्योंकि एक द्वि-आयामी सरणी में कई सरणियाँ होती हैं, इसके माध्यम से पुनरावृति करने और इसके सभी मूल्यों को प्रदर्शित करने के लिए (या इसके सभी तत्वों को आबाद करने के लिए), हमें एक नेस्टेड लूप की आवश्यकता होती है:
for (int i = 0; i < cats.length; i++) {
for (int j = 0; j < cats[i].length; j++) {
System.out.println(cats[i][j]);
}
}
बाहरी पाश (चर i) में, हम अपने द्वि-आयामी सरणी में सभी सरणियों पर पुनरावृति करते हैं। आंतरिक पाश (चर j) में, हम प्रत्येक सरणी के सभी तत्वों से गुजरते हैं। नतीजतन, बिल्लियों [0] [0] (पहला सरणी, पहला तत्व) पहले प्रदर्शित किया जाएगा, उसके बाद बिल्लियों [0] [1] (पहला सरणी, दूसरा तत्व)। पहली सरणी से गुजरने के बाद, हम बिल्लियों [1] [0] , बिल्लियों [1] [1] , बिल्लियों [1] [2] आदि को प्रदर्शित करेंगे । वैसे, द्वि-आयामी सरणियाँ भी समर्थन करती हैं आशुलिपि आरंभीकरण:
int[][] numbers = {{1,2,3}, {4,5,6}, {7,8,9}};
आमतौर पर, हम द्वि-आयामी सरणी को numbersएक के रूप में घोषित करेंगे int[3][3], लेकिन यह आशुलिपि हमें तुरंत मान निर्दिष्ट करने देती है। आपको द्वि-आयामी सरणी की आवश्यकता क्यों होगी? ठीक है, आप प्रसिद्ध "बैटलशिप" गेम को आसानी से फिर से बनाने के लिए एक का उपयोग कर सकते हैं: "बैटलशिप" में, खेल के मैदान की संरचना को आसानी से वर्णित किया जा सकता है: प्रत्येक 10 तत्वों के साथ 10 सरणियों का द्वि-आयामी सरणी। आप इनमें से दो सरणियाँ बनाते हैं (एक आपके लिए और एक आपके प्रतिद्वंद्वी के लिए)
int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];
अपने जहाजों के स्थान के अनुरूप तत्वों को पॉप्युलेट करने के लिए कुछ मानों (जैसे संख्या या प्रतीक) का उपयोग करें, और फिर विशिष्ट तत्वों के निर्देशांकों को बारी-बारी से कॉल करें:
युद्धपोत बोर्ड 1 [0] [2]!
कुमारी! युद्धपोत बोर्ड 2 [2] [4]!
मार!
युद्धपोत बोर्ड 2 [2] [5]!
मार!
युद्धपोत बोर्ड 2 [2] [6]!,
डूब!
यह सरणियों के हमारे पहले परिचय को समाप्त करता है, लेकिन यह केवल उनके साथ हमारी बातचीत की शुरुआत है। निम्नलिखित पाठों में, हम दिलचस्प तरीके देखेंगे जिनका उपयोग किया जा सकता है, और यह भी सीखेंगे कि जावा में कौन से अंतर्निहित कार्य हैं जो हमें इस डेटा संरचना के साथ और अधिक आसानी से काम करने देते हैं :)
एक सरणी में "बक्से" भी होते हैं। आप प्रत्येक बॉक्स में कुछ (एक तत्व) डाल सकते हैं। किसी तत्व तक पहुँचने के लिए, आपको उसका बॉक्स नंबर (इंडेक्स) जानना होगा। इस प्रकार एक सरणी बनाई जाती है:
में कुछ मूल्य रखना चाहते हैं , तो आप यह करते हैं:
यह समझना महत्वपूर्ण है कि एक सरणी केवल वस्तुओं को संग्रहीत नहीं करती है: यह स्वयं एक वस्तु है। यह हमें इस सवाल की ओर ले जाता है कि क्या हम न केवल स्ट्रिंग्स या संख्याओं की सरणी बना सकते हैं, बल्कि सरणी के सरणी भी बना सकते हैं । और जवाब है हां, हम कर सकते हैं! एक सरणी अन्य सरणियों सहित किसी भी वस्तु को संग्रहीत कर सकती है। ऐसी सरणी को द्वि-आयामी कहा जाता है । यदि हम इसे दृश्य रूप में प्रस्तुत करें, तो यह एक साधारण तालिका के समान ही होगा। मान लीजिए, हम 3 सरणियों की एक सरणी बनाना चाहते हैं जो प्रत्येक 10 
"बैटलशिप" में, खेल के मैदान की संरचना को आसानी से वर्णित किया जा सकता है: प्रत्येक 10 तत्वों के साथ 10 सरणियों का द्वि-आयामी सरणी। आप इनमें से दो सरणियाँ बनाते हैं (एक आपके लिए और एक आपके प्रतिद्वंद्वी के लिए)
GO TO FULL VERSION