जावा में 2 डी सरणी की सरणी लंबाई प्राप्त करना

Question

मुझे पंक्ति और स्तंभ दोनों के लिए 2 डी सरणी की लंबाई प्राप्त करने की आवश्यकता है। मैंने निम्न कोड का उपयोग करते हुए इसे सफलतापूर्वक किया है:

public class MyClass {

 public static void main(String args[])
    {
  int[][] test; 
  test = new int[5][10];

  int row = test.length;
  int col = test[0].length;

  System.out.println(row);
  System.out.println(col);
    }
}

यह उम्मीद के मुताबिक 5, 10 प्रिंट करता है।

अब इस लाइन पर एक नज़र डालें:

  int col = test[0].length;

ध्यान दें कि मुझे वास्तव में एक विशेष पंक्ति को संदर्भित करना है, ताकि कॉलम की लंबाई मिल सके। मेरे लिए, यह अविश्वसनीय रूप से बदसूरत लगता है। इसके अतिरिक्त, यदि सरणी को इस रूप में परिभाषित किया गया था:

test = new int[0][10];

तब लंबाई प्राप्त करने की कोशिश करते समय कोड विफल हो जाएगा। क्या ऐसा करने का एक अलग (अधिक बुद्धिमान) तरीका है?

Comments

मुझे निम्नलिखित संदर्भ काफी व्यापक लगा, programiz.com/java-programming/multidimensional-array

— होसैन रहिमी

Answer 1

विचार करें

public static void main(String[] args) {

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

    System.out.println(foo.length); //2
    System.out.println(foo[0].length); //3
    System.out.println(foo[1].length); //4
}

कॉलम की लंबाई प्रति पंक्ति भिन्न होती है। यदि आप एक निश्चित आकार के 2D सरणी द्वारा कुछ डेटा का समर्थन कर रहे हैं, तो एक रैपर वर्ग में निश्चित मान के लिए गेटर्स प्रदान करें।

Comments

आपके उत्तर के बारे में असंबंधित प्रश्न। वह तकनीक / विधि क्या है जिसे आपने "{...};" कहा है ऑब्जेक्ट परिभाषा के बाद। एक नए डेवलपर के रूप में मैं इसे अधिक से अधिक देखता रहूंगा।

— user432209

खैर, मैं समझता हूँ कि बहुत :)। मुझे लगा कि तकनीक के लिए एक विशिष्ट नाम हो सकता है।

— 194 बजे user432209

निश्चित नहीं है कि इसका नाम क्या है - वस्तु आरंभीकरण? इनलाइन आरंभीकरण? हमारे जावा गुरुओं में से एक को पता होगा

— एनजी।

प्रति JLS 10.6 और 15.10, घुंघराले ब्रेसिज़ भाग केवल एक ऐरे इनिशियलाइज़र है, जबकि नई के साथ शुरू होने वाली पूरी चीज़ एक ऐरे क्रिएशन एक्सप्रेशन है।

— ILMTitan

Answer 2

एक 2D सरणी एक आयताकार ग्रिड नहीं है। या शायद बेहतर है, जावा में 2 डी सरणी जैसी कोई चीज नहीं है।

import java.util.Arrays;

public class Main {
  public static void main(String args[]) {

    int[][] test; 
    test = new int[5][];//'2D array'
    for (int i=0;i<test.length;i++)
      test[i] = new int[i];

    System.out.println(Arrays.deepToString(test));

    Object[] test2; 
    test2 = new Object[5];//array of objects
    for (int i=0;i<test2.length;i++)
      test2[i] = new int[i];//array is a object too

    System.out.println(Arrays.deepToString(test2));
  }
}

आउटपुट

[[], [0], [0, 0], [0, 0, 0], [0, 0, 0, 0]]
[[], [0], [0, 0], [0, 0, 0], [0, 0, 0, 0]]

सरणियाँ testऔर test2हैं (कमोबेश) वही।

Answer 3

यह याद रखना वास्तव में कठिन था

    int numberOfColumns = arr.length;
    int numberOfRows = arr[0].length;

आइए समझते हैं कि ऐसा क्यों है और जब हम किसी सरणी समस्या को देखते हैं तो हम इसका पता कैसे लगा सकते हैं। नीचे दिए गए कोड से हम देख सकते हैं कि पंक्तियाँ = 4 और कॉलम = 3:

    int[][] arr = { {1, 1, 1, 1}, 

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arrइसमें कई सरणियाँ हैं, और इन सरणियों को स्तंभों की संख्या प्राप्त करने के लिए एक ऊर्ध्वाधर तरीके से व्यवस्थित किया जा सकता है। पंक्तियों की संख्या प्राप्त करने के लिए, हमें पहले सरणी तक पहुंचने और इसकी लंबाई पर विचार करने की आवश्यकता है। इस स्थिति में, हम [1, 1, 1, 1] का उपयोग करते हैं और इस प्रकार, पंक्तियों की संख्या = 4. जब आपको एक समस्या दी जाती है जहां आप सरणी को नहीं देख सकते हैं, तो आप सरणी को आयत के रूप में देख सकते हैं n एक्स एम आयाम और निष्कर्ष निकालते हैं कि हम पहले सरणी फिर इसकी लंबाई तक पहुंचकर पंक्तियों की संख्या प्राप्त कर सकते हैं। अन्य एक ( arr.length) कॉलम के लिए है।

Comments

आपके पास यह पीछे है। "इस मामले में, हम [1, 1, 1, 1] का उपयोग करते हैं और इस प्रकार, पंक्तियों की संख्या = 4." दरअसल, इसका मतलब है कि 4 कॉलम हैं।

— इवान रोजिका

सही @ इवान रोसिका

— नितिन नंदा

Answer 4

जावा आपको "रैग्ड एरे" बनाने की अनुमति देता है जहां प्रत्येक "पंक्ति" में अलग-अलग लंबाई होती है। यदि आप जानते हैं कि आपके पास एक वर्ग सरणी है, तो आप इस तरह से खाली सरणी से बचाने के लिए अपने कोड को संशोधित कर सकते हैं:

if (row > 0) col = test[0].length;

Answer 5

यदि आपके पास यह सरणी है:

String [][] example = {{{"Please!", "Thanks"}, {"Hello!", "Hey", "Hi!"}},
                       {{"Why?", "Where?", "When?", "Who?"}, {"Yes!"}}};

तुम यह केर सकते हो:

example.length;

= २

example[0].length;

= २

example[1].length;

= २

example[0][1].length;

= ३

example[1][0].length;

= 4

Comments

मैंने पहले भी इसी तरह का उत्तर देखा था, लेकिन मुझे लगता है कि उदाहरणों के साथ समझना आसान है!

Answer 6

भाषा के स्तर पर एक क्लीनर तरीका नहीं है क्योंकि सभी बहुआयामी सरणियों आयताकार नहीं हैं। कभी-कभी दांतेदार (कॉलम की लंबाई अलग) सरणियां आवश्यक हैं।

आप आसानी से अपनी कार्यक्षमता बनाने के लिए अपनी खुद की कक्षा बना सकते हैं।

यदि आप सरणियों तक सीमित नहीं हैं, तो शायद विभिन्न संग्रह वर्गों में से कुछ मल्टीमैप की तरह काम करेंगे ।

Answer 7

.length = पंक्तियों की संख्या / स्तंभ की लंबाई

[०]। गति = स्तंभों की संख्या / पंक्ति की लंबाई

Comments

एसओ में आपका स्वागत है। आपको अपने उत्तर में कुछ और स्पष्टीकरण जोड़ना चाहिए।

— m02ph3u5

Answer 8

जावा में 2 डी सरणी के लिए इस कार्यक्रम की कोशिश करें:

public class ArrayTwo2 {
    public static void main(String[] args) throws  IOException,NumberFormatException{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int[][] a;
        int sum=0;
        a=new int[3][2];
        System.out.println("Enter array with 5 elements");
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[0].length;j++)
            {
            a[i][j]=Integer.parseInt(br.readLine());
            }
        }
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[0].length;j++)
            {
            System.out.print(a[i][j]+"  ");
            sum=sum+a[i][j];
            }
        System.out.println();   
        //System.out.println("Array Sum: "+sum);
        sum=0;
        }
    }
}

Answer 9

import java.util.Arrays;

public class Main {

    public static void main(String[] args) 
    {

        double[][] test = { {100}, {200}, {300}, {400}, {500}, {600}, {700}, {800}, {900}, {1000}};

        int [][] removeRow = { {0}, {1}, {3}, {4}, };

        double[][] newTest = new double[test.length - removeRow.length][test[0].length];

        for (int i = 0, j = 0, k = 0; i < test.length; i++) {
            if (j < removeRow.length) {
                if (i == removeRow[j][0]) {
                    j++;
                    continue;
                }
            }
            newTest[k][0] = test[i][0];
            k++;
        }

        System.out.println(Arrays.deepToString(newTest));   
    }
}

Comments

प्रिंट करेगा [[300.0], [600.0], [700.0], [800.0], [900.0], [1000.0]] दशमलव बिंदु को खोने के लिए ints में परिवर्तित करें। यह समाधान मानता है कि आपका इनपुट सरणी हमेशा आकार का होगा ([x] [1])

— RobynVG

Answer 10

इसके साथ Java 8, आप इस तरह से कुछ और सुरुचिपूर्ण करने की अनुमति देते हैं:

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

int length = Arrays.stream(array).max(Comparator.comparingInt(ArrayUtils::getLength)).get().length

Answer 11

public class Array_2D {
int arr[][];
public Array_2D() {
    Random r=new Random(10);
     arr = new int[5][10];
     for(int i=0;i<5;i++)
     {
         for(int j=0;j<10;j++)
         {
             arr[i][j]=(int)r.nextInt(10);
         }
     }
 }
  public void display()
  {
         for(int i=0;i<5;i++)

         {
             for(int j=0;j<10;j++)
             {
                 System.out.print(arr[i][j]+" "); 
             }
             System.out.println("");
         }
   }
     public static void main(String[] args) {
     Array_2D s=new Array_2D();
     s.display();
   }  
  }

Comments

यह प्रश्न से संबंधित नहीं है

— alfonso.kim