J'ai besoin d'obtenir la longueur d'un tableau 2D pour la ligne et la colonne. J'ai réussi cela, en utilisant le code suivant:

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

Cela imprime 5, 10 comme prévu.

Jetez maintenant un œil à cette ligne:

  int col = test[0].length;

Notez que je dois en fait référencer une ligne particulière, afin d'obtenir la longueur de la colonne. Pour moi, cela semble incroyablement moche. De plus, si le tableau a été défini comme:

test = new int[0][10];

Ensuite, le code échouerait en essayant d'obtenir la longueur. Existe-t-il une manière différente (plus intelligente) de faire cela?

Considérer

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
}

Les longueurs de colonne diffèrent par ligne. Si vous sauvegardez certaines données par un tableau 2D de taille fixe, fournissez des getters aux valeurs fixes dans une classe wrapper.

Un tableau 2D n'est pas une grille rectangulaire. Ou peut-être mieux, il n'existe pas de tableau 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));
  }
}

Les sorties

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

Les tableaux testet test2sont (plus ou moins) les mêmes.

C'était vraiment difficile de se souvenir de ça

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

Comprenons pourquoi il en est ainsi et comment nous pouvons le résoudre lorsque nous avons un problème de tableau. À partir du code ci-dessous, nous pouvons voir que les lignes = 4 et les colonnes = 3:

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

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arrcontient plusieurs tableaux, et ces tableaux peuvent être disposés verticalement pour obtenir le nombre de colonnes. Pour obtenir le nombre de lignes, nous devons accéder au premier tableau et considérer sa longueur. Dans ce cas, nous accédons à [1, 1, 1, 1] et donc, le nombre de lignes = 4. Lorsque vous rencontrez un problème où vous ne pouvez pas voir le tableau, vous pouvez visualiser le tableau sous forme de rectangle avec n X m dimensions et conclure que nous pouvons obtenir le nombre de lignes en accédant au premier tableau puis à sa longueur. L'autre ( arr.length) est pour les colonnes.

Java vous permet de créer des «tableaux irréguliers» où chaque «ligne» a des longueurs différentes. Si vous savez que vous avez un tableau carré, vous pouvez utiliser votre code modifié pour vous protéger contre un tableau vide comme celui-ci:

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

Si vous possédez ce tableau:

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

Tu peux le faire:

example.length;

= 2

example[0].length;

= 2

example[1].length;

= 2

example[0][1].length;

= 3

example[1][0].length;

= 4

Il n'y a pas de méthode plus propre au niveau du langage car tous les tableaux multidimensionnels ne sont pas rectangulaires. Des tableaux irréguliers (différentes longueurs de colonne) sont parfois nécessaires.

Vous pouvez facilement créer votre propre classe pour résumer les fonctionnalités dont vous avez besoin.

Si vous n'êtes pas limité aux tableaux, alors peut-être que certaines des différentes classes de collection fonctionneraient également, comme un Multimap .

.length = nombre de lignes / longueur de colonne

[0] .length = nombre de colonnes / longueur de ligne

Essayez ce programme suivant pour 2d array 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));   
    }
}

Avec Java 8, vous permet de faire quelque chose de plus élégant comme celui-ci:

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