पुस्तक "सभी के लिए जावा"

हाय, हब्रोज़ितेली! यह पुस्तक शुरुआती लोगों के लिए है।

कई सालों से, जावा भाषा सबसे लोकप्रिय और बाद की मांग की गई है। यह सुंदर, प्रभावी और, सबसे महत्वपूर्ण, बहुत उत्पादक है। लेकिन, दुर्भाग्य से, सबसे आसान नहीं है। यही कारण है कि जावा प्रोग्रामर की मांग लगातार अधिक है। जावा भाषा एक हीरा है जो किसी भी प्रोग्रामर के ज्ञान के सामान को सुशोभित करेगा। और जावा सीखना, जैसा कि मुझे आशा है, इस पुस्तक के पाठकों को यह सुनिश्चित करना होगा कि यह न केवल उपयोगी है, बल्कि दिलचस्प भी है। पुस्तक का आधार व्याख्यान पाठ्यक्रम है, अलग-अलग समय पर, जिसे मैंने कीव विश्वविद्यालय के भौतिकी के संकाय के आचार्यों के नाम पर पढ़ा। Tarasa Shevchenko, यूक्रेन के नेशनल टेक्निकल यूनिवर्सिटी "कीव पॉलिटेक्निक इंस्टीट्यूट" के मेडिकल-इंजीनियरिंग संकाय के स्नातक और विभिन्न प्रोग्रामिंग पाठ्यक्रमों के छात्र हैं। पुस्तक की सामग्री और प्रस्तुति का तरीका उन सभी के लिए अनुकूलित है जो न केवल जावा को शैक्षिक संस्थानों में सीखना चाहते हैं, बल्कि स्वतंत्र रूप से भी। इसलिए, पुस्तक को एक ट्यूटोरियल के रूप में इस्तेमाल किया जा सकता है।

सरणियों

एक सरणी का मतलब एक ही प्रकार के मान (चर) का एक सेट है, जिसे एक सामान्य नाम से एक्सेस किया जा सकता है। यह अध्याय सरणियों के लिए समर्पित है।

एक सरणी से संबंधित चर को इस सरणी के तत्व कहा जाता है। किसी सरणी के तत्व को विशिष्ट रूप से पहचानने के लिए, आपको सरणी के तत्व के नाम और स्थिति (स्थान) को जानना होगा। सरणी में तत्वों की स्थिति पूर्णांक सूचकांकों का उपयोग करके निर्धारित की जाती है। किसी सरणी के एक तत्व को पहचानने के लिए आवश्यक सूचकांकों की संख्या को सरणी का आयाम कहा जाता है। एक-आयामी सरणी एक सरणी है जिसमें तत्वों को एकल सूचकांक का उपयोग करके पहचाना जाता है।

एक आयामी सारणी

चर की अनुक्रमित श्रृंखला या अनुक्रम के रूप में एक ही आयामी सरणी की कल्पना करना सुविधाजनक है (एक ही प्रकार का)। एक-आयामी सरणी घोषित करने के लिए, आपको उस प्रकार को निर्दिष्ट करना होगा जिसमें सरणी के तत्व हैं, सरणी का नाम और सरणी में शामिल तत्वों की संख्या भी। एक आयामी सरणी घोषित करने के लिए सिंटैक्स है:

[] =new []; 

सबसे पहले, सरणी के तत्वों के प्रकार को इंगित किया जाता है, और प्रकार के बाद पहचानकर्ता खाली वर्ग कोष्ठक द्वारा पीछा किया जाता है। अगला, सरणी का नाम, असाइनमेंट ऑपरेटर, निर्देश (ऑपरेटर) नया, फिर से सरणी के तत्वों का प्रकार और वर्ग कोष्ठक में सरणी का आकार (सरणी में तत्वों की संख्या)। उदाहरण के लिए, int num = नया int [20] कमांड 20 तत्वों का पूर्णांक संख्या सरणी घोषित करता है।

कड़ाई से बोलते हुए, यहाँ प्रस्तुत सरणी घोषणा कमान दो आज्ञाओं का सहजीवन है: int [] कमांड संख्या "प्रकार पूर्णांक सरणी" (सरणी चर) और नया int [20] निर्देश के एक चर संख्या की घोषणा करते हैं, जो वास्तव में, सरणी बनाता है। इस निर्देश को अंकों के चर का मान सौंपा गया है, और सरणी संदर्भ के परिणामस्वरूप, इसे अंक चर के लिए लिखा जाता है। दूसरे शब्दों में, एक सरणी बनाने की प्रक्रिया को दो कमांड के साथ किया जा सकता है:

 int[] nums; nums=new int[20]; 

इसके अलावा, इन आदेशों को प्रोग्राम कोड में पोस्ट किया जा सकता है - अर्थात, हम एक ऐरे वेरिएबल की घोषणा कर सकते हैं और उसके बाद ही, कोड में किसी अन्य स्थान पर, एक ऐरे बनाते हैं (और ऐरे वेरिएबल में इस एरे का लिंक लिखते हैं)।

विवरण पहले, हम मुख्य रूप से बुनियादी, या आदिम, प्रकार (जैसे इंट, चार या डबल) से निपटते हैं। आधार प्रकार का एक चर मान को संग्रहीत करता है। तकनीकी रूप से, यह इस तरह दिखता है: स्मृति में एक चर के लिए एक स्थान आवंटित किया जाता है, और चर का मूल्य इस स्थान पर लिखा जाता है। लेकिन डेटा के साथ काम करने का एक और तरीका है जिसमें एक चर डेटा को संदर्भित करता है। ऑब्जेक्ट्स के साथ ऐसा होता है, और इसलिए सरणियों को लागू किया जाता है। वास्तव में एक सरणी है, लेकिन हम इसे सीधे एक्सेस नहीं करते हैं, लेकिन एक मध्यस्थ की मदद से, जो एक सरणी चर है। सरणी चर का मान सरणी नहीं है, लेकिन सरणी का पता है। इसलिए, एक सरणी चर बनाने का मतलब एक सरणी बनाना नहीं है। एक सरणी अलग से बनाई गई है। हम इस स्थिति का वर्णन करेंगे जिसमें एक सरणी चर एक सरणी को संदर्भित करता है। हर बार हमें एरे को एक्सेस करने की आवश्यकता होती है, हम एरे वेरिएबल को एक्सेस करेंगे जो दिए गए एरे को संदर्भित करता है।
हालांकि पहली नज़र में ऐसी योजना बेमानी लग सकती है, फिर भी, इसके फायदे हैं। और हम इसे देखेंगे।

ऐसे मामलों में जहां कोई गलतफहमी नहीं है, हम सरणी के साथ सरणी चर की पहचान करेंगे।

एक सरणी चर की घोषणा करते समय, यह स्क्वायर ब्रैकेट को इंगित करने के लिए या तो प्रकार पहचानकर्ता या सरणी नाम के बाद इंगित करने की अनुमति देता है। उदाहरण के लिए, int [] nums कमांड के बजाय, आप int num [] कमांड का उपयोग कर सकते हैं।

एक-आयामी सरणी का एक तत्व वर्ग कोष्ठक में संकेतित तत्व के सूचकांक के साथ सरणी के नाम से पहुँचा जाता है। अनुक्रमण सरणी तत्व शून्य से शुरू होता है। इस प्रकार, अंक सरणी के पहले तत्व का संदर्भ अंक की तरह दिखेगा [0]। यदि सरणी में 20 तत्व हैं, तो सरणी के अंतिम तत्व में 19 का सूचकांक है, अर्थात तत्व तक पहुंचने का निर्देश अंक [19] जैसा दिखता है।

सरणी की लंबाई को लंबाई संपत्ति का उपयोग करके पाया जा सकता है: सरणी का नाम इंगित किया गया है और, डॉट के माध्यम से, लंबाई संपत्ति। उदाहरण के लिए, अंक सरणी की लंबाई का पता लगाने के लिए, आप संख्यात्मक गति कथन का उपयोग कर सकते हैं। फिर सरणी के अंतिम तत्व के संदर्भ को अंक [nums.length -1] के रूप में लिखा जा सकता है।

सूचना जावा यह देखने के लिए एक स्वचालित जांच का उपयोग करता है कि क्या यह सरणी से बाहर जाता है। इसलिए, यदि कोड एक गैर-स्थिर सरणी तत्व को संदर्भित करता है, तो एक त्रुटि होती है।

एक ऐरे की घोषणा करते समय, इसके लिए मेमोरी आवंटित की जाती है। जावा में, सरणी तत्व स्वचालित रूप से शून्य मानों के साथ आरंभिक होते हैं - चयनित कोशिकाएँ शून्य होती हैं, और इन शून्य कोशिकाओं के मानों की व्याख्या सरणी के प्रकार के आधार पर की जाती है। लेकिन आपको इस तरह के स्वचालित आरंभ पर भरोसा नहीं करना चाहिए। एरे के तत्वों को स्पष्ट रूप से आरम्भ करना बुद्धिमानी है। ऐसा करने के लिए, ऐरे की घोषणा करते समय लूप ऑपरेटर का उपयोग करें या तत्व मानों की सूची निर्दिष्ट करें।

सरणी चर घोषित करते समय मानों की एक सूची के साथ सरणी को आरंभीकृत करने के लिए, यह संकेत दिए जाने के बाद (असाइनमेंट ऑपरेटर के माध्यम से) ब्रेसिज़ में संलग्न मानों की एक सूची है। उदाहरण के लिए:

 int[] data={3,8,1,7}; 

यहां, पूर्णांक सरणी के लिए चर डेटा घोषित किया गया है, एक सरणी बनाई गई है, और इसके लिए एक लिंक इस चर के लिए लिखा गया है। मूल्यों की सूची में तत्वों की संख्या के अनुसार सरणी का आकार और तत्वों का मान स्वचालित रूप से निर्धारित किया जाता है। इस स्थिति में, चार तत्वों के पूर्णांक सरणी को तत्वों 3, 8, 1 और 7 के मानों के साथ बनाया गया है। उदाहरण के लिए, निम्न आदेशों का उपयोग करके एक ही परिणाम प्राप्त किया जा सकता है:

 int[] data; data=new int[]{3,8,1,7}; 

पहला int [] डेटा कमांड एक ऐरे वेरिएबल की घोषणा करता है। निर्देश नया int [] {3,8,1,7} चार पूर्णांकों की एक सरणी बनाता है, और इस सरणी का एक संदर्भ चर डेटा को निर्दिष्ट किया जाता है (कमांड डेटा = नया int [] {3,8,1,7}) ।
सारणी 3.1 में ऐरे को घोषित करने, आरंभ करने और उपयोग करने का एक उदाहरण दिखाया गया है।

लिस्टिंग 3.1। पेश है वन-डायमेंशनल एरियर्स

 class Demo{ public static void main(String[] args){ //  : int i,n; //   : int[] data; //  : data=new int[]{3,8,1,7}; //  : n=data.length; //  : int[] nums=new int[n]; //   : for(i=0;i<nums.length;i++){ nums[i]=2*data[i]-3; System.out.println("nums["+i+"]="+nums[i]); } } } 

कार्यक्रम चार तत्वों के डेटा सरणी की घोषणा करता है और आरंभ करता है। सरणी की लंबाई की गणना data.length स्टेटमेंट द्वारा की जाती है। यह मान पूर्णांक चर n (कमांड n = data.length) के लिए लिखा गया है। इसके बाद, int [] nums = new int [n] कमांड एक और पूर्णांक संख्या सरणी घोषित करता है। इस सरणी में तत्वों की संख्या चर n के मान से निर्धारित होती है, इसलिए, यह डेटा सरणी के आकार के साथ मेल खाता है। अंक सरणी भरना एक लूप स्टेटमेंट का उपयोग करके किया जाता है। डेटा सरणी के तत्वों (कमांड अंक [i] = 2 * डेटा [i] -3) के मानों के आधार पर अंक सरणी के तत्वों के मूल्यों की गणना की जाती है। अंक सरणी के तत्वों के मूल्यों को प्रदर्शित करने के लिए, System.out.println कमांड ("अंक [" + + i + "] =" + संख्या [i]) का उपयोग करें।

निम्नलिखित से पता चलता है कि कार्यक्रम निष्पादन का परिणाम कैसा दिखता है:
कार्यक्रम का परिणाम (सूची 3.1 से)

 nums[0]=3 nums[1]=13 nums[2]=-1 nums[3]=11 

एक बार फिर, हम ध्यान दें कि सरणी तत्वों का अनुक्रमण शून्य से शुरू होता है। इसलिए, लूप ऑपरेटर में, इंडेक्स वेरिएबल I को प्रारंभिक शून्य मान के साथ आरंभीकृत किया जाता है, और सख्त असमानता ऑपरेटर का उपयोग परीक्षण स्थिति i <nums.length में किया जाता है।
यह भी महत्वपूर्ण है कि अंक सरणी बनाते समय, इसका आकार चर n का उपयोग करके निर्धारित किया जाता है, जिसका मूल्य कार्यक्रम के निष्पादन के दौरान गणना की जाती है।

द्वि-आयामी और बहुआयामी सरणियाँ

सरणी का आयाम एक से अधिक हो सकता है। लेकिन व्यवहार में, दूसरे से अधिक आयाम के सरणियों का उपयोग शायद ही कभी किया जाता है। अगला, हम द्वि-आयामी सरणियों को घोषित करने, आरंभ करने और उपयोग करने के तरीकों पर ध्यान देंगे, जिसमें दो अनुक्रमों का उपयोग करके किसी सरणी के एक तत्व तक पहुंच का प्रदर्शन किया जाता है। यदि आप तालिका के रूप में दो-आयामी सरणी का प्रतिनिधित्व करते हैं, तो तत्व का पहला सूचकांक उस पंक्ति को निर्धारित करता है जिसमें तत्व स्थित है, और दूसरा सूचकांक उस स्तंभ को निर्धारित करता है जिसमें तत्व स्थित है।

विवरण हालांकि दो-आयामी सरणी को तालिका के रूप में आसानी से दर्शाया गया है, इसे पूरी तरह से अलग तरीके से लागू किया गया है। वास्तव में, जावा में एक द्वि-आयामी सरणी एक-आयामी सरणी है जिसके तत्व सरणी चर हैं। ऐसा प्रत्येक चर एक आयामी सरणी को संदर्भित करता है। इस निर्माण का उपयोग करते समय, भ्रम पैदा होता है कि हम एक तालिका के साथ काम कर रहे हैं।

द्वि-आयामी सरणियों का निर्माण उतना ही सरल है जितना कि एक-आयामी सरणियों का निर्माण। लेकिन जब दो-आयामी सरणी के लिए एक चर घोषित करते हैं, तो दो प्रकार के खाली वर्ग कोष्ठक को पहचानकर्ता के बाद संकेत दिया जाता है, और दो-आयामी सरणी बनाने के लिए निर्देश - अलग-अलग वर्ग कोष्ठक में - प्रत्येक सूचकांकों के लिए आकार (सरणी में पंक्तियों और स्तंभों की संख्या) को इंगित करता है। द्वि-आयामी सरणी घोषित करने के लिए सिंटैक्स निम्नानुसार है:

 [][] =new [][]; 

एक-आयामी सरणी के मामले में, इस आदेश को दो में विभाजित किया जा सकता है:

 [][] ; =new [][]; 

पहला आदेश दो-आयामी सरणी के लिए एक चर घोषित करता है। दूसरा कमांड निर्दिष्ट आकारों के साथ एक वास्तविक दो आयामी सरणी बनाता है, और इस सरणी के संदर्भ को सरणी चर के मान के रूप में सौंपा गया है। उदाहरण के लिए, डबल [] [] डेटा = नया डबल [3] [4] कमांड दोहरे प्रकार के तत्वों के साथ एक दो आयामी सरणी बनाता है। सरणी में 3 पंक्तियाँ और 4 स्तंभ हैं, और सरणी के लिए लिंक डेटा चर में लिखा गया है। समान आदेशों का परिणाम समान होगा:

 double[][] data; data=new double[3][4]; 

दो-आयामी सरणी के तत्वों तक पहुंच निम्न प्रारूप में की जाती है: सरणी का नाम इंगित किया गया है, वर्ग कोष्ठक में तत्व का पहला सूचकांक है, अन्य वर्ग कोष्ठक में सरणी के तत्व का दूसरा सूचकांक है। सभी आयामों में अनुक्रमण खरोंच से शुरू होता है। उदाहरण के लिए, डेटा [0] [3] लिंक सूचक 0 और 3 के साथ डेटा सरणी के एक तत्व के लिए एक कॉल है, और यह पहली पंक्ति और चौथे कॉलम में एक तत्व है।

दो-आयामी सरणी शुरू करने के लिए, नेस्टेड लूप ऑपरेटरों या मूल्यों की सूची से युक्त एक सूची का उपयोग किया जाता है। प्रत्येक ऐसी आंतरिक सूची एक स्ट्रिंग में सरणी तत्वों के मूल्यों को परिभाषित करती है। एक सूची का उपयोग करके दो-आयामी सरणी को आरम्भ करने के उदाहरण निम्नलिखित हैं:

 double[][] data={{0.1,0.2,0.3},{0.4,0.5,0.6}}; int nums[][]={{1,2,3},{4,5}}; 

पहला कमांड 3 द्वि-आयामी डेटा सरणी (दो पंक्तियों और तीन स्तंभों) से 2 बनाता है और आरंभ करता है। बाहरी सूची में तत्वों की संख्या से पंक्तियों की संख्या निर्धारित की जाती है। ऐसे दो तत्व हैं - ये सूचियाँ {0.1,0.2,0.3} और {0.4,0.5,0.6} हैं। इनमें से प्रत्येक सूची में तीन तत्व हैं। यहाँ से हमें आकार 2 की एक सरणी मिलती है। 3. सूची {0.1,0.2,0.3} पहली पंक्ति में तत्वों के मूल्यों को परिभाषित करती है, सूची {0.4,0.5,0.6} दूसरी पंक्ति में तत्वों के मूल्यों को परिभाषित करती है। उदाहरण के लिए, डेटा [0] [0] तत्व को मान 0.1, डेटा [0] [2] तत्व को मान 0.3, डेटा [1] [0] तत्व को मान 0.4 प्राप्त होता है, और डेटा [1] [2] तत्व को मान 0.6 मिलता है। ।

दूसरी कमांड एक पूर्णांक अंक सरणी बनाता है, जिसमें दो लाइनें शामिल होती हैं (चूंकि निर्दिष्ट सूची के अंदर दो तत्व हैं - सूचियां {1,2,3} और {4,5})। हालाँकि, बनाई गई सरणी की पहली पंक्ति में तीन तत्व होते हैं (क्योंकि सूची में तीन मान {1,2,3}) हैं, और सरणी की दूसरी पंक्ति में दो तत्व हैं (क्योंकि सूची में दो मान {4,5}) हैं। निर्मित सरणी में, संख्या [0] [0] तत्व का मान 1 है, अंक [0] [1] तत्व का मूल्य 2 है, अंक [0] [2] तत्व का मूल्य 3 है, अंक [1] [0] तत्व का मूल्य 4 है। और तत्व संख्या [1] [१] का मान ५ है।

विवरण समस्या यह है कि अलग-अलग लाइनों में अंक सरणी में तत्वों की एक अलग संख्या होती है, नहीं। तकनीकी रूप से, सब कुछ बस से अधिक कार्यान्वित किया जाता है। द्वि-आयामी सरणी अंकों का चर वास्तव में दो तत्वों के एक-आयामी सरणी (दो-आयामी आयामों में पंक्तियों की संख्या) को संदर्भित करता है। लेकिन इस सरणी के तत्व पूर्णांक नहीं हैं, लेकिन चर जो एक आयामी पूर्णांक सरणियों का उल्लेख कर सकते हैं (अपेक्षाकृत बोलना, तत्व प्रकार int [] हैं)। पहला चर तीन तत्वों (1, 2 और 3) के एक आयामी आयाम को संदर्भित करता है, और दूसरा चर तीन तत्वों (4 और 5) के एक आयामी आयाम को संदर्भित करता है। जब हम सूचकांक (एक सूचकांक के साथ!) अंक चर, हम इस चर द्वारा संदर्भित एक-आयामी सरणी के तत्व तक पहुंच प्राप्त करते हैं। उदाहरण के लिए, अंक [0] पहला तत्व है, और अंक [1] सरणी चर से उल्लिखित सरणी का दूसरा तत्व है। और ये तत्व सरणियों के संदर्भ हैं। उन्हें अनुक्रमित किया जा सकता है। इसलिए, मान लें कि अंक [0] [1] सरणी का दूसरा तत्व है, पहला अंक [0] तत्व उस सरणी को संदर्भित करता है जो अंक चर को संदर्भित करता है। तो वास्तव में सब कुछ होता है। और हम अंकों की व्याख्या करते हैं [0] [1] पहली पंक्ति में एक तत्व के लिए और दो आयामी सरणी के दूसरे कॉलम में एक अपील के रूप में निर्देश।

3.2 को सूचीबद्ध करना एक ऐसे कार्यक्रम का एक उदाहरण दिखाता है जो दो-आयामी सरणी बनाता है जो नेस्टेड लूप स्टेटमेंट्स का उपयोग करके पॉपुलेटेड है।

लिस्टिंग 3.2। द्वि-आयामी सरणी बनाएं

 class Demo{ public static void main(String[] args){ int i,j,n=3,val=1; //   : int[][] nums=new int[n-1][n]; //   : for(i=0;i<n-1;i++){ //    for(j=0;j<n;j++){ //    //   : nums[i][j]=val++; //   : System.out.print(nums[i][j]+" "); } //    : System.out.println(); } } } 

Int [] [] nums = नया int [n-1] [n] कमांड n-1 पंक्तियों और n कॉलम के साथ पूर्णांक संख्या सरणी बनाता है। वैरिएबल n को पूर्व-नियत मान दिया गया है। सरणी नेस्टेड लूप ऑपरेटरों का उपयोग करके भरा गया है। सरणी तत्व (दिए गए सूचकांकों i और j के लिए) का मान कमांड संख्या [i] [j] = val ++ द्वारा दिया गया है। यहाँ, num [i] [j] तत्व को वैरिएबल वैल का वर्तमान मान असाइन किया गया है, और उसके तुरंत बाद वेरिएबल वैल का मान एक से बढ़ जाता है।

नोट वैल ++ इंस्ट्रक्शन को निष्पादित करने के परिणामस्वरूप, वैरिएबल वैल का मान एक से बढ़ जाता है। लेकिन चूंकि वेतन वृद्धि ऑपरेटर के पोस्टफिक्स फॉर्म का उपयोग किया जाता है, इसलिए वैरिएबल वैल का मान वेरिएबल वैल के पुराने (एक से बढ़ कर पहले) वैल्यू है।

तत्व के मूल्य की गणना करने के बाद, इसे आउटपुट क्षेत्र में प्रदर्शित किया जाता है। कार्यक्रम के परिणामस्वरूप, हमें मिलता है:
कार्यक्रम का परिणाम (लिस्टिंग 3.2 से)

 1 2 3 4 5 6 

3.3 लिस्टिंग एक प्रोग्राम के लिए कोड दिखाता है जो विभिन्न लंबाई के तारों के साथ एक दो-आयामी सरणी बनाता है।

लिस्टिंग 3.3। विभिन्न लंबाई के तारों के साथ सरणी

 class Demo{ public static void main(String[] args){ int i,j,val=1; //   (   ): int[][] nums=new int[4][]; //     : for(i=0;i<nums.length;i++){ //    : nums[i]=new int[i+1]; } //  : for(i=0;i<nums.length;i++){ for(j=0;j<nums[i].length;j++){ //   : nums[i][j]=val++; //   : System.out.print(nums[i][j]+" "); } //    : System.out.println(); } } } 

Int [] [] संख्या = नया int [4] [] कमांड दो आयामी पूर्णांक संख्या सरणी बनाता है। इस सरणी में चार पंक्तियाँ हैं। हालांकि, लाइनों का आकार निर्दिष्ट नहीं है - कमांड के अंत में वर्ग ब्रैकेट की दूसरी जोड़ी खाली है। अधिक सटीक रूप से, अभी तक कोई रेखाएं नहीं हैं। उन्हें बनाने की जरूरत है। लूप स्टेटमेंट में लाइनें बनाई जाती हैं। इस लूप स्टेटमेंट में, इंडेक्स वैरिएबल 0 से लेकर न्यूमेसलिफ्ट -1, इनक्लूसिव के जरिए चलता है। अंक [i] = नया int [i + 1] कमांड इंडेक्स i के साथ द्वि-आयामी सरणी की एक पंक्ति बनाता है। ऐसी स्ट्रिंग में i + 1 तत्व है।

विवरण तकनीकी रूप से, सब कुछ इस तरह होता है: नया int [i + 1] निर्देश एक आयामी सरणी (दो आयामी सरणी के लिए एक स्ट्रिंग) बनाता है और इस सरणी का एक संदर्भ संख्या [i] चर के लिए लिखा जाता है। इस स्थिति में, अंक [i] को सूचकांक I के साथ एक पंक्ति के लिंक के रूप में व्याख्या किया जा सकता है। संख्यात्मक गति निर्देश का अर्थ स्पष्ट हो जाएगा यदि आपको याद है कि वास्तव में एक द्वि-आयामी सरणी एक आयामी आयाम है, जिसके तत्व एक-आयामी सरणियों को संदर्भित करते हैं। इस स्थिति में, nums.length अंक चर द्वारा संदर्भित सरणी में तत्वों की संख्या के लिए एक मान देती है - अर्थात, यह द्वि-आयामी सरणी में पंक्तियों की संख्या है।

नतीजतन, हमें त्रिकोणीय प्रकार का एक दो-आयामी सरणी मिलता है: सरणी की पहली पंक्ति में एक तत्व होता है, दूसरे में - दो तत्व, और इसी तरह, सरणी की चौथी पंक्ति तक।
निर्मित सरणी नेस्टेड लूप ऑपरेटरों का उपयोग करके भरी गई है। एक्सटर्नल लूप ऑपरेटर में इंडेक्स वैरिएबल 0 से संख्यात्मकता -1 तक मान लेता है और द्वि-आयामी संख्यात्मक सरणी में एक पंक्ति को परिभाषित करता है। इंडेक्स वेरिएबल जे के लिए, भिन्नता की सीमा की ऊपरी सीमा को अंकों [i] .length निर्देश द्वारा निर्धारित किया जाता है, जो इंडेक्स i के साथ पंक्ति में तत्वों की संख्या को लौटाता है (जे वेरिएबल 0 से अंकों के बीच बदलता है [i] .length -1 शामिल करता है)।

विवरण यह ध्यान दिया जाना चाहिए कि अंक [i], वास्तव में, एक चर है जो इंडेक्स I के साथ एक स्ट्रिंग बनाने वाले एक आयामी सरणी को संदर्भित करता है। इस सरणी (स्ट्रिंग) में तत्वों की संख्या अभिव्यक्ति संख्या [i] .length द्वारा निर्धारित की जाती है।

सरणी तत्वों का मान कमांड अंक [i] [j] = val ++ द्वारा दिया गया है। निम्नलिखित से पता चलता है कि कार्यक्रम निष्पादन का परिणाम कैसा दिखता है:
कार्यक्रम का परिणाम (लिस्टिंग 3.3 से)

 1 2 3 4 5 6 7 8 9 10 

जैसा कि अपेक्षित था, हमें एक सरणी मिली जिसमें विभिन्न पंक्तियों में विभिन्न संख्याएँ हैं।

NOTICE Arrays, जिसका आयाम दो से अधिक है, उसी तरह से बनाए गए हैं। बहुआयामी सरणी के लिए एक चर घोषित करते समय, प्रकार के पहचानकर्ता के बाद खाली ब्रैकेट के जोड़े को दर्शाया जाता है। इस तरह के जोड़े की संख्या सरणी के आयाम से निर्धारित होती है। सरणी निर्माण कमांड में, प्रत्येक सूचकांक का आकार अलग-अलग वर्ग कोष्ठक में इंगित किया गया है।

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

फेरीवालों के लिए कूपन पर 25% की छूट - जावा

पुस्तक के पेपर संस्करण के भुगतान पर, एक इलेक्ट्रॉनिक पुस्तक ई-मेल द्वारा भेजी जाती है।