अॅरे बद्दल काहीतरी

हाय! पूर्वी तुमच्या प्रशिक्षणात, आम्ही एकल वस्तू (आणि आदिम प्रकार) सह काम केले आहे. पण जर आपल्याला फक्त एका ऐवजी वस्तूंच्या संपूर्ण गटासह कार्य करण्याची आवश्यकता असेल तर? उदाहरणार्थ, आम्हाला आमच्या कंपनीतील सर्व कर्मचार्‍यांच्या वाढदिवसांची यादी तयार करायची आहे असे म्हणा. त्यामध्ये खालीलप्रमाणे स्वरूपित केलेल्या 30 स्ट्रिंग्स असाव्यात: "सारा हफमन, 25 जानेवारी" आम्हाला अॅरे नावाच्या विशेष डेटा स्ट्रक्चरचा फायदा होईल . जर आपण अॅरेची वास्तविक ऑब्जेक्टशी तुलना केली, तर ती सेफ्टी डिपॉझिट बॉक्ससह बँक व्हॉल्टसारखीच असते: अॅरेमध्ये "बॉक्स" देखील असतात. तुम्ही प्रत्येक बॉक्समध्ये काहीतरी (घटक) टाकू शकता. घटकामध्ये प्रवेश करण्यासाठी, तुम्हाला त्याचा बॉक्स क्रमांक (इंडेक्स) माहित असणे आवश्यक आहे. अशा प्रकारे अॅरे तयार केला जातो:

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10];
      
   }
}

येथे आपण एक अॅरे तयार करतो ज्यामध्ये 10 घटक असतात. आपण अॅरेची काही वैशिष्ट्ये त्वरित लक्षात घेऊ शकता:

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


2. अॅरे तयार केल्यावर त्याचा आकार निर्दिष्ट करणे आवश्यक आहे . तुम्ही ते नंतर सूचित करू शकत नाही किंवा अॅरे तयार झाल्यानंतर त्याचा आकार बदलू शकत नाही .

आपण अॅरे तयार करत आहोत ही वस्तुस्थिती अभिव्यक्तीच्या दोन्ही बाजूंच्या चौरस कंसाने दर्शविली जाते. ते संदर्भ व्हेरिएबलच्या नावापूर्वी किंवा नंतर निर्दिष्ट केले जाऊ शकतात. कोणत्याही प्रकारे कार्य करेल:

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 असलेला बॉक्स शोधा आणि तेथे असलेली व्हॅल्यू rosieBirthdayString व्हेरिएबलला द्या ". आणि नेमकं तेच झालं. अ‍ॅरेसह कार्य करताना, आम्ही विशेष गुणधर्म वापरून त्यांची लांबी सहजपणे शोधू शकतो: लांबी .

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याप्रमाणे s ची अॅरे तयार करू शकता:

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");
   }
}

आपल्याला येथे काही गोष्टी समजून घेणे आवश्यक आहे:

1. आदिमांच्या बाबतीत, अॅरे विशिष्ट मूल्यांचा संच (उदा. ints) संग्रहित करते. ऑब्जेक्ट्सच्या बाबतीत, अॅरे संदर्भांचा संच संग्रहित करते .
   अ‍ॅरेमध्ये catsतीन घटक असतात, त्यातील प्रत्येक वस्तूचा संदर्भCat असतो . प्रत्येक संदर्भ मेमरी पत्त्याकडे निर्देश करतो जेथे संबंधित ऑब्जेक्ट संग्रहित केला जातो.

2. अॅरे घटक मेमरीमध्ये एकाच ब्लॉकमध्ये व्यवस्थित केले जातात. त्यांना जलद आणि कार्यक्षमतेने प्रवेश मिळावा यासाठी हे केले जाते.

अशा प्रकारे, 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];

तुमच्या जहाजांच्या स्थानाशी संबंधित घटक तयार करण्यासाठी काही मूल्ये (उदा. संख्या किंवा चिन्हे) वापरा आणि नंतर विशिष्ट घटकांसाठी निर्देशांक कॉल करा:

• battleshipBoard1[0][2]!
• मिस! battleshipBoard2[2][4]!
• मारा!
• battleshipBoard2[2][5]!
• मारा!
• बॅटलशिपबोर्ड2[2][6]!,
• बुडाले!

हे अॅरेच्या आमच्या पहिल्या परिचयाचा निष्कर्ष काढते, परंतु त्यांच्याशी आमच्या परस्परसंवादाची ही केवळ सुरुवात आहे. पुढील धड्यांमध्ये, आम्ही ते वापरण्याचे मनोरंजक मार्ग पाहू आणि Java कडे कोणती अंगभूत फंक्शन्स आहेत ते आम्हाला या डेटा स्ट्रक्चरसह अधिक सोयीस्करपणे कार्य करू देते हे देखील जाणून घेऊ :)