द्वि-आयामी सरणी बनाने के लिए सिंटैक्स

Question

विचार करें:

int[][] multD = new int[5][];
multD[0] = new int[10];

क्या यह है कि आप 5 पंक्तियों और 10 स्तंभों के साथ दो आयामी सरणी कैसे बनाते हैं?

मैंने इस कोड को ऑनलाइन देखा, लेकिन वाक्य रचना का कोई मतलब नहीं था।

Comments

पहले स्टेटमेंट में 10 कॉलम होने के कारण yea दो आयामी एरे को भी परिभाषित कर सकता है। int [] [] बहु = नया int [५] [१०];

— committedandroider

Answer 1

निम्नलिखित आज़माएँ:

int[][] multi = new int[5][10];

... जो इस तरह से कुछ के लिए एक छोटा हाथ है:

int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];

ध्यान दें कि प्रत्येक तत्व के लिए डिफ़ॉल्ट मान पर प्रारंभ हो जाएगा int, 0है, इसलिए ऊपर भी के बराबर हैं:

int[][] multi = new int[][]{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

Comments

मज़े की बात यह है कि आपके पास अलग-अलग पंक्तियों में अलग-अलग कॉलम भी हो सकते हैं। उदाहरण के लिए: - int [] [] बहु = नया int [५] []; मल्टी [0] = नया इंट [10]; मल्टी [1] = नया इंट [6]; बहु [२] = नया int [९] भी पूरी तरह से मान्य है

— जावा

हाय मुनीब, अगर मुझे सही तरीके से समझ में आया, तो आप बहु-आयामी सरणी में पूछ रहे हैं, प्रत्येक पंक्ति के लिए अलग-अलग कॉलम आकार के साथ, मान कैसे निर्दिष्ट करें। यहाँ बताया गया है: int [] [] बहु = नया int [] [] {{१,२,३}, {१,२,३,४}, {१}}; और आप उन्हें एक्सेस कर सकते हैं / प्रिंट कर सकते हैं जैसे: (int i = 0; i <multi.length; i ++) {for (int j = 0; j <multi [i] .length; j ++) {system.out.println ( "पंक्ति:" + i + "कॉलम:" + j + "मूल्य:" + बहु [i] [j]); }}

— JavaTec

क्या हमें वेरिएंट new int[][]में उपयोग करने की आवश्यकता है =new int[][]{...}? क्या हम सिर्फ लिख सकते हैं ={...}?

— नवाज

@ नवाज़ नहीं, एरेज़ जावा में ऑब्जेक्ट हैं और मेमोरी केवल newकीवर्ड का उपयोग करके ऑब्जेक्ट को आवंटित की जाती है ।

— रोज़ट्रेलर

@ ओल्ड्रिन int array[][] = new int[3][];वीएस के बारे में क्या int array[][] = new int[][3];?? जो एक कानूनी है क्योंकि मैंने दोनों संस्करणों को कहीं पढ़ा है।

— रोज़ट्रेलर

Answer 2

हम इसकी घोषणा के समय एक दो आयामी सरणी और सीधे तत्वों को स्टोर कर सकते हैं:

int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

यहाँ int सरणी में संग्रहीत पूर्णांक प्रकार के तत्वों का प्रतिनिधित्व करता है और सरणी का नाम 'निशान' है। int "{" और "}" ब्रेसिज़ के अंदर दर्शाए गए सभी तत्वों के लिए डेटाटाइप है क्योंकि एक सरणी समान डेटा प्रकार वाले तत्वों का एक संग्रह है।

ऊपर लिखे हमारे बयान पर वापस आ रहे हैं: तत्वों की प्रत्येक पंक्ति घुंघराले ब्रेसिज़ के अंदर लिखी जानी चाहिए। प्रत्येक पंक्ति में पंक्तियों और तत्वों को अल्पविराम द्वारा अलग किया जाना चाहिए।

अब कथन का अवलोकन करें: आप प्राप्त कर सकते हैं 3 पंक्तियाँ और 5 स्तंभ हैं, इसलिए JVM मेमोरी के 3 * 5 = 15 ब्लॉक बनाता है। इन ब्लॉकों को व्यक्तिगत रूप से टा कहा जा सकता है:

marks[0][0]  marks[0][1]  marks[0][2]  marks[0][3]  marks[0][4]
marks[1][0]  marks[1][1]  marks[1][2]  marks[1][3]  marks[1][4]
marks[2][0]  marks[2][1]  marks[2][2]  marks[2][3]  marks[2][4]

नोट:
यदि आप n तत्वों को संग्रहीत करना चाहते हैं तो सरणी सूचकांक शून्य से शुरू होता है और n-1 पर समाप्त होता है । दो आयामी सरणी बनाने का एक और तरीका है, पहले सरणी को घोषित करना और फिर नए ऑपरेटर का उपयोग करके इसके लिए मेमोरी आवंटित करना।

int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

उपरोक्त दो को मिलाकर हम लिख सकते हैं:

int marks[][] = new int[3][5];

Comments

मुझे लगता है कि डेटा दर्ज करने का यह सबसे आसान तरीका है।

— thanos.a

Answer 3

आप उन्हें वैसे ही बना सकते हैं, जैसा दूसरों ने उल्लेख किया है। जोड़ने के लिए एक और बिंदु: आप प्रत्येक पंक्ति के साथ एक तिरछी दो-आयामी सरणी भी बना सकते हैं, जरूरी नहीं कि समान संख्या में कॉलम हों, जैसे:

int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];

Comments

खूब कहा है! स्वतंत्र आरंभीकरण होने का यह सबसे महत्वपूर्ण पहलू है।

— शहीद

@ विक्टर int array[][] = new int[3][];वीएस के बारे में क्या int array[][] = new int[][3];?? जो एक कानूनी है क्योंकि मैंने दोनों संस्करणों को कहीं पढ़ा है।

— रोटरवेलर

Answer 4

5 पंक्तियों और 10 स्तंभों के साथ एक दो आयामी सरणी बनाने के लिए सबसे आम मुहावरा है:

int[][] multD = new int[5][10];

_{वैकल्पिक रूप से, आप निम्नलिखित का उपयोग कर सकते हैं, जो आपके पास के समान है, हालांकि आपको प्रत्येक पंक्ति को स्पष्ट रूप से प्रारंभ करने की आवश्यकता है:}

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
  multD[i] = new int[10];
}

Comments

यह भी महसूस करें कि केवल आदिम लोगों को आरंभीकरण की आवश्यकता नहीं है। यदि आप सरणी घोषित करते हैं Object[][] ary2d = new Object[5][10];तो आपको अभी भी 2 डी सरणी के प्रत्येक तत्व को इनिशियलाइज़ करना होगा।

— आर्मंड

जब तक आप nullकिसी भी गैर आदिम के लिए मामले को सुरक्षित रूप से नहीं संभालते । आपको प्रत्येक तत्व को आरम्भ करना चाहिए या नहीं, यह पूरी तरह से आपके डिजाइन पर निर्भर करता है। इसके अलावा, बस स्पष्ट करने के लिए - आदिमों को शून्य नहीं किया जा सकता है और यदि आपके द्वारा एक को नहीं सौंपा गया है तो परिभाषित डिफ़ॉल्ट मान पर त्वरित रूप से प्राप्त किया जा सकता है। उदाहरण के intलिए, शून्य नहीं हो सकता है और जब आप int i;मान बताए बिना कहते हैं , तो डिफ़ॉल्ट 0का उपयोग किया जाता है। इसके बारे में यहाँ पढ़ें

— अविभाज्य

एक और स्पष्टीकरण, डिफ़ॉल्ट मान केवल वर्ग / उदाहरण चर के लिए दिए गए हैं। स्थानीय चर (विधियों के अंदर) को उपयोग करने से पहले मैन्युअल रूप से आरंभ किया जाना चाहिए।

— अविभाजित

Answer 5

इसे निम्नलिखित तरीके से घोषित करना भी संभव है। यह अच्छा डिज़ाइन नहीं है, लेकिन यह काम करता है।

int[] twoDimIntArray[] = new int[5][10];

Answer 6

प्रयत्न:

int[][] multD = new int[5][10];

ध्यान दें कि आपके कोड में केवल 2 डी सरणी की पहली पंक्ति को 0. पंक्ति 2 से 5 तक आरंभीकृत किया गया है। यदि आप उन्हें मुद्रित करने का प्रयास करते हैं, तो आप उन nullसभी के लिए प्राप्त करेंगे ।

Answer 7

int [][] twoDim = new int [5][5];

int a = (twoDim.length);//5
int b = (twoDim[0].length);//5

for(int i = 0; i < a; i++){ // 1 2 3 4 5
    for(int j = 0; j <b; j++) { // 1 2 3 4 5
        int x = (i+1)*(j+1);
        twoDim[i][j] = x;
        if (x<10) {
            System.out.print(" " + x + " ");
        } else {
            System.out.print(x + " ");
        }
    }//end of for J
    System.out.println();
}//end of for i

Answer 8

जावा में, एक द्वि-आयामी सरणी को एक-आयामी सरणी के समान घोषित किया जा सकता है। एक-आयामी सरणी में आप जैसे लिख सकते हैं

  int array[] = new int[5];

जहाँ int एक डेटा प्रकार है, सरणी [] एक सरणी घोषणा है, और new arrayपांच अनुक्रमित के साथ अपनी वस्तुओं के साथ एक सरणी है।

उस तरह, आप निम्न के रूप में दो-आयामी सरणी लिख सकते हैं।

  int array[][];
  array = new int[3][4];

यहाँ arrayएक int data type है। मैंने सबसे पहले उस प्रकार के एक आयामी सरणी पर घोषित किया है, फिर एक 3 पंक्ति और 4 कॉलम सरणी बनाई गई है।

अपने कोड में

int[][] multD = new int[5][];
multD[0] = new int[10];

इसका मतलब है कि आपने पांच पंक्तियों के साथ एक दो आयामी सरणी बनाई है। पहली पंक्ति में 10 कॉलम हैं। जावा में आप अपनी इच्छानुसार हर पंक्ति के लिए कॉलम आकार का चयन कर सकते हैं।

Answer 9

int rows = 5;
int cols = 10;

int[] multD = new int[rows * cols];

for (int r = 0; r < rows; r++)
{
  for (int c = 0; c < cols; c++)
  {
     int index = r * cols + c;
     multD[index] = index * 2;
  }
}

का आनंद लें!

Comments

यह एक ऐसी भाषा में उपयोगी होगा जो C जैसी 2D सरणियों का समर्थन नहीं करता है!

— आला

C बहुआयामी सरणियों का भी समर्थन करता है।

— रिकार्डो क्रूज़

Answer 10

इस तरह आजमाएं:

int a[][] = {{1,2}, {3,4}};

int b[] = {1, 2, 3, 4};

Answer 11

इस प्रकार के सरणियों को जावा में दांतेदार सरणियों के रूप में जाना जाता है:

int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];

इस परिदृश्य में सरणी की प्रत्येक पंक्ति स्तंभों की भिन्न संख्या रखती है। उपरोक्त उदाहरण में, पहली पंक्ति में तीन कॉलम होंगे, दूसरी पंक्ति में दो कॉलम होंगे, और तीसरी पंक्ति में पांच कॉलम होंगे। आप इस सरणी को नीचे के संकलन समय पर आरंभ कर सकते हैं:

 int[][] multD = {{2, 4, 1}, {6, 8}, {7, 3, 6, 5, 1}};

आप आसानी से अपने सरणी में सभी तत्वों को पुन: व्यवस्थित कर सकते हैं:

for (int i = 0; i<multD.length; i++) {
    for (int j = 0; j<multD[i].length; j++) {
        System.out.print(multD[i][j] + "\t");
    }
    System.out.println();
}

Answer 12

वास्तव में जावा में गणितीय अर्थों में बहु-आयामी सरणी नहीं है। जावा में केवल सारणियां हैं, एक सरणी जहां प्रत्येक तत्व भी एक सरणी है। यही कारण है कि इसे शुरू करने की पूर्ण आवश्यकता पहले आयाम का आकार है। यदि बाकी निर्दिष्ट किए जाते हैं तो यह डिफ़ॉल्ट मान के साथ आबादी वाला एक सरणी बनाएगा।

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

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

int[][]   ar  = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1]    = new int[] {1,2,3,4,5,6}; // works