Devo ottenere la lunghezza di un array 2D sia per la riga che per la colonna. L'ho fatto con successo, usando il seguente codice:

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

Questo stampa 5, 10 come previsto.

Ora dai un'occhiata a questa linea:

  int col = test[0].length;

Si noti che in realtà devo fare riferimento a una riga particolare, al fine di ottenere la lunghezza della colonna. A me sembra incredibilmente brutto. Inoltre, se l'array è stato definito come:

test = new int[0][10];

Quindi il codice fallirebbe quando si tenta di ottenere la lunghezza. Esiste un modo diverso (più intelligente) per farlo?

Tener conto di

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
}

Le lunghezze delle colonne differiscono per riga. Se si esegue il backup di alcuni dati da un array 2D di dimensioni fisse, fornire getter ai valori fissi in una classe wrapper.

Un array 2D non è una griglia rettangolare. O forse meglio, non esiste un array 2D in Java.

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

Uscite

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

Gli array teste test2sono (più o meno) gli stessi.

È stato davvero difficile ricordarlo

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

Capiamo perché è così e come possiamo capire quando ci viene dato un problema di matrice. Dal codice qui sotto possiamo vedere che righe = 4 e colonne = 3:

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

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arrcontiene più array e questi array possono essere disposti in modo verticale per ottenere il numero di colonne. Per ottenere il numero di righe, dobbiamo accedere al primo array e considerare la sua lunghezza. In questo caso, accediamo a [1, 1, 1, 1] e quindi, il numero di righe = 4. Quando ti viene dato un problema in cui non puoi vedere l'array, puoi visualizzare l'array come un rettangolo con n X m dimensioni e concludere che possiamo ottenere il numero di righe accedendo al primo array e alla sua lunghezza. L'altro ( arr.length) è per le colonne.

Java consente di creare "array irregolari" in cui ogni "riga" ha lunghezze diverse. Se sai di avere un array quadrato, puoi usare il tuo codice modificato per proteggerti da un array vuoto come questo:

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

Se hai questo array:

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

Puoi farlo:

example.length;

= 2

example[0].length;

= 2

example[1].length;

= 2

example[0][1].length;

= 3

example[1][0].length;

= 4

Non esiste un modo più pulito a livello di linguaggio perché non tutti gli array multidimensionali sono rettangolari. A volte sono necessarie matrici frastagliate (di diversa lunghezza delle colonne).

Puoi facilmente creare la tua classe per astrarre le funzionalità di cui hai bisogno.

Se non sei limitato agli array, forse anche alcune delle varie classi di raccolta funzionerebbero, come una Multimap .

.length = numero di righe / lunghezza della colonna

[0] .length = numero di colonne / lunghezza riga

Prova questo programma seguente per 2d array in Java:

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

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

Con Java 8, ti permetto di fare qualcosa di più elegante come questo:

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

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