द्विमितीय अॅरे

1. द्विमितीय अॅरे

अॅरे बद्दल आणखी एक मनोरंजक तथ्य. अॅरे केवळ एक-आयामी (रेखीय) नसतात. ते द्विमितीय देखील असू शकतात.

याचा अर्थ काय, तुम्ही विचारता?

याचा अर्थ असा की अॅरेचे सेल केवळ स्तंभ (किंवा पंक्ती)च नव्हे तर आयताकृती सारणी देखील दर्शवू शकतात.

int[][] name = new int[width][height];

जेथे नाव हे अॅरे व्हेरिएबलचे नाव आहे, रुंदी ही टेबलची रुंदी (सेलमध्ये) आहे आणि उंची ही टेबलची उंची आहे. उदाहरण:

int[][] data = new int[2][5];
data[1][1] = 5;

मेमरीमध्ये ते असे दिसेल:

तसे, तुम्ही द्वि-आयामी अॅरेसाठी जलद आरंभिकरण देखील वापरू शकता:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

अशी अनेक ठिकाणे आहेत जिथे तुम्हाला, प्रोग्रामर म्हणून, द्विमितीय अॅरेची आवश्यकता असू शकते. द्विमितीय अॅरे हा जवळजवळ प्रत्येक बोर्ड गेमचा पाया असतो, उदा. बुद्धिबळ, चेकर्स, टिक-टॅक-टो आणि समुद्र युद्ध:

द्विमितीय अॅरे बुद्धिबळ किंवा समुद्राच्या लढाईसाठी योग्य आहेत. आम्हाला फक्त सेल कोऑर्डिनेट्स फॉर्म संख्या आवश्यक आहे. 'प्यादा e2-e4' नाही तर 'प्यादा (5,2) -> (5,4)'. प्रोग्रामर म्हणून तुमच्यासाठी हे आणखी सोपे होईल.

2. अॅरेमध्ये घटकांची मांडणी करणे: (x, y) किंवा (y, x)

तसे, येथे एक मनोरंजक कोंडी आहे:

जेव्हा आपण वापरून अॅरे तयार करतो , तेव्हा आपल्याकडे 'दोन पंक्ती आणि 5 स्तंभnew int[2][5]; ' ची सारणी असते की ती 'दोन स्तंभ आणि 5 पंक्ती ' असते?" दुसऱ्या शब्दांत, आपण प्रथम रुंदी आणि नंतर उंची निर्दिष्ट करत आहोत... किंवा याउलट, प्रथम उंची आणि नंतर रुंदी? ठीक आहे, जसे आपण अनेकदा म्हणतो, येथे सर्वकाही इतके सोपे नाही.

अॅरे मेमरीमध्ये कसे साठवले जाते या प्रश्नापासून सुरुवात करूया .

अर्थात, संगणक मेमरीमध्ये प्रत्यक्षात मॅट्रिक्स नसते: मेमरीमधील प्रत्येक स्थानाचा अनुक्रमिक अंकीय पत्ता असतो: 0, 1, 2, ... आमच्या बाबतीत, आम्ही 2 × 5 मॅट्रिक्सबद्दल बोलतो, परंतु मेमरीमध्ये हे फक्त 10 सलग सेल आहे, आणखी काही नाही. पंक्ती आणि स्तंभ कुठे आहेत हे काहीही दर्शवत नाही.

"रुंदी x उंची" च्या बाजूने युक्तिवाद.

या दृष्टिकोनाच्या बाजूने युक्तिवाद असा आहे की प्रत्येकजण शाळेत गणित शिकतो, जिथे ते शिकतात की समन्वय जोड्या 'x' (म्हणजे, क्षैतिज अक्ष) आणि नंतर 'y' (उभ्या परिमाण) लिहिल्या जातात. आणि हे फक्त शालेय मानक नाही - हे गणितातील सामान्यतः स्वीकारलेले मानक आहे. जसे ते म्हणतात, आपण गणिताशी वाद घालू शकत नाही. असं आहे का? आधी रुंदी आणि नंतर उंची?

"उंची x रुंदी" च्या बाजूने युक्तिवाद.

या स्थितीसाठी एक मनोरंजक युक्तिवाद देखील आहे: द्विमितीय अॅरेचे जलद आरंभीकरण. खरंच, जर आम्हाला आमचा अ‍ॅरे सुरू करायचा असेल, तर आम्ही याप्रमाणे कोड लिहू शकतो:

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

तुमच्या काही लक्षात येत नाही का? आमच्याकडे हे असेल तर?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

जर आपण आपला डेटा कोड लाईनमध्ये ओळीने लिहिला तर आपल्याला 2 रो आणि 5 कॉलम असलेले मॅट्रिक्स मिळेल.

तळ ओळ

आम्ही काय म्हणू शकतो? आपल्यासाठी कोणते अधिक सोयीचे आहे हे ठरविणे आपल्यावर अवलंबून आहे. सर्वात महत्त्वाची गोष्ट म्हणजे एकाच प्रकल्पावर काम करणारे सर्व प्रोग्रामर समान दृष्टिकोनाला चिकटून राहतात.

जर तुम्ही अशा प्रकल्पावर काम करत असाल ज्याच्या कोडमध्ये अनेक आरंभिक द्विमितीय अॅरे असतील, तर बहुधा तेथे सर्व काही जलद डेटा इनिशिएलायझेशनवर आधारित असेल, म्हणजे तुमच्याकडे मानक 'उंची x रुंदी' असेल.

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

3. द्विमितीय अॅरे कसे व्यवस्थित केले जातात

आणि आता तुम्ही शिकू शकाल की द्विमितीय अॅरे प्रत्यक्षात कसे मांडले जातात. तयार?

द्विमितीय अॅरे हे खरं तर अॅरेचे अॅरे आहेत!

दुसर्‍या शब्दांत, जर सामान्य अॅरेच्या बाबतीत अॅरे व्हेरिएबल अॅरे घटक संचयित करणाऱ्या कंटेनरचा संदर्भ संग्रहित करते, तर द्विमितीय अॅरेच्या बाबतीत परिस्थिती थोडीशी स्फोटक होते: द्वि-आयामी-अॅरे व्हेरिएबल संचयित करते कंटेनरचा संदर्भ जो एक-आयामी अॅरेचा संदर्भ संग्रहित करतो. शंभर वेळा समजावून सांगण्यापेक्षा ते एकदा कृतीत पाहणे चांगले आहे:

डावीकडे , आमच्याकडे द्वि-आयामी-अ‍ॅरे व्हेरिएबल आहे, जे द्विमितीय-अ‍ॅरे ऑब्जेक्टचा संदर्भ संग्रहित करते . मध्येमध्यभागी आपल्याकडे द्विमितीय अॅरे ऑब्जेक्ट आहे ज्याचे सेल एक-आयामी अॅरे साठवतात, जे द्विमितीय अॅरेच्या पंक्ती आहेत. आणि उजवीकडे , तुम्ही चार एक-आयामी अॅरे पाहू शकता — आमच्या द्विमितीय अॅरेच्या पंक्ती.

अशा प्रकारे द्विमितीय अॅरे प्रत्यक्षात कार्य करतात. आणि हा दृष्टिकोन Java प्रोग्रामरला अनेक फायदे देतो:

प्रथम , 'कंटेनरचा कंटेनर' 'पंक्तींच्या अ‍ॅरे' चा संदर्भ देत असल्याने, आपण पंक्तींची अदलाबदल करू शकतो. 'कंटेनरचा कंटेनर' मिळविण्यासाठी, तुम्हाला दोन ऐवजी फक्त एक निर्देशांक निर्दिष्ट करावा लागेल. उदाहरण:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

हा कोड तुम्हाला पंक्ती स्वॅप करू देतो:

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

जर तुम्ही द्वि-आयामी अॅरेच्या सेलचा संदर्भ घेत असाल, परंतु तुम्ही अॅरेच्या नावानंतर फक्त एक अनुक्रमणिका निर्दिष्ट केली असेल, तर तुम्ही कंटेनरच्या कंटेनरचा संदर्भ देत आहात ज्यांचे सेल सामान्य एक-आयामी अॅरेचे संदर्भ संग्रहित करतात.