Necesito obtener la longitud de una matriz 2D tanto para la fila como para la columna. Lo hice con éxito, usando el siguiente código:

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

Esto imprime 5, 10 como se esperaba.

Ahora eche un vistazo a esta línea:

  int col = test[0].length;

Tenga en cuenta que realmente tengo que hacer referencia a una fila en particular, para obtener la longitud de la columna. Para mí, esto me parece increíblemente feo. Además, si la matriz se definió como:

test = new int[0][10];

Entonces el código fallaría al intentar obtener la longitud. ¿Hay una manera diferente (más inteligente) de hacer esto?

Considerar

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
}

Las longitudes de columna difieren por fila. Si está respaldando algunos datos mediante una matriz 2D de tamaño fijo, proporcione captadores a los valores fijos en una clase de contenedor.

Una matriz 2D no es una cuadrícula rectangular. O tal vez mejor, no existe una matriz 2D en 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));
  }
}

Salidas

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

Las matrices testy test2son (más o menos) iguales.

Fue muy difícil recordar eso

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

Comprendamos por qué esto es así y cómo podemos resolver esto cuando se nos presenta un problema de matriz. Del siguiente código podemos ver que filas = 4 y columnas = 3:

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

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arrtiene múltiples matrices, y estas matrices se pueden organizar de forma vertical para obtener el número de columnas. Para obtener el número de filas, necesitamos acceder a la primera matriz y considerar su longitud. En este caso, accedemos a [1, 1, 1, 1] y, por lo tanto, el número de filas = 4. Cuando se le presenta un problema en el que no puede ver la matriz, puede visualizar la matriz como un rectángulo con n X m dimensiones y concluimos que podemos obtener el número de filas accediendo a la primera matriz y luego a su longitud. El otro ( arr.length) es para las columnas.

Java le permite crear "matrices desiguales" donde cada "fila" tiene diferentes longitudes. Si sabe que tiene una matriz cuadrada, puede usar su código modificado para protegerse contra una matriz vacía como esta:

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

Si tienes esta matriz:

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

Puedes hacerlo:

example.length;

= 2

example[0].length;

= 2

example[1].length;

= 2

example[0][1].length;

= 3

example[1][0].length;

= 4

No hay una forma más limpia a nivel de lenguaje porque no todas las matrices multidimensionales son rectangulares. A veces son necesarias matrices irregulares (diferentes longitudes de columna).

Podría crear fácilmente su propia clase para abstraer la funcionalidad que necesita.

Si no está limitado a las matrices, quizás algunas de las diversas clases de colección también funcionarían, como un Multimap .

.length = número de filas / longitud de columna

[0] .length = número de columnas / longitud de fila

Pruebe este siguiente programa para la matriz 2D en 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, te permite hacer algo más elegante como este:

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