Ich muss die Länge eines 2D-Arrays sowohl für die Zeile als auch für die Spalte ermitteln. Ich habe dies erfolgreich mit dem folgenden Code durchgeführt:

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

Dies druckt wie erwartet 5, 10 aus.

Schauen Sie sich nun diese Zeile an:

  int col = test[0].length;

Beachten Sie, dass ich tatsächlich auf eine bestimmte Zeile verweisen muss, um die Spaltenlänge zu erhalten. Für mich scheint das unglaublich hässlich. Wenn das Array außerdem definiert wurde als:

test = new int[0][10];

Dann würde der Code fehlschlagen, wenn versucht wird, die Länge zu ermitteln. Gibt es einen anderen (intelligenteren) Weg, dies zu tun?

Erwägen

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
}

Die Spaltenlängen unterscheiden sich pro Zeile. Wenn Sie einige Daten mit einem 2D-Array fester Größe sichern, stellen Sie Getter für die festen Werte in einer Wrapper-Klasse bereit.

Ein 2D-Array ist kein rechteckiges Gitter. Oder vielleicht besser, es gibt kein 2D-Array 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));
  }
}

Ausgänge

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

Die Arrays testund test2sind (mehr oder weniger) gleich.

Es war wirklich schwer, sich daran zu erinnern

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

Lassen Sie uns verstehen, warum dies so ist und wie wir dies herausfinden können, wenn wir ein Array-Problem erhalten. Aus dem folgenden Code können wir erkennen, dass Zeilen = 4 und Spalten = 3 sind:

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

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arrEs enthält mehrere Arrays, und diese Arrays können vertikal angeordnet werden, um die Anzahl der Spalten zu ermitteln. Um die Anzahl der Zeilen zu ermitteln, müssen wir auf das erste Array zugreifen und dessen Länge berücksichtigen. In diesem Fall greifen wir auf [1, 1, 1, 1] und damit auf die Anzahl der Zeilen = 4 zu. Wenn Sie ein Problem haben, bei dem Sie das Array nicht sehen können, können Sie das Array als Rechteck mit anzeigen n X m Dimensionen und schließen Sie, dass wir die Anzahl der Zeilen erhalten können, indem wir auf das erste Array und dann auf seine Länge zugreifen. Der andere (arr.length ) ist für die Spalten.

Mit Java können Sie "zerlumpte Arrays" erstellen, bei denen jede "Zeile" unterschiedliche Längen hat. Wenn Sie wissen, dass Sie ein quadratisches Array haben, können Sie Ihren geänderten Code verwenden, um sich vor einem leeren Array wie folgt zu schützen:

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

Wenn Sie dieses Array haben:

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

Du kannst das:

example.length;

= 2

example[0].length;

= 2

example[1].length;

= 2

example[0][1].length;

= 3

example[1][0].length;

= 4

Auf Sprachebene gibt es keinen saubereren Weg, da nicht alle mehrdimensionalen Arrays rechteckig sind. Manchmal sind gezackte Arrays (unterschiedliche Spaltenlängen) erforderlich.

Sie können ganz einfach eine eigene Klasse erstellen, um die von Ihnen benötigten Funktionen zu abstrahieren.

Wenn Sie nicht auf Arrays beschränkt sind, funktionieren möglicherweise auch einige der verschiedenen Auflistungsklassen, z. B. eine Multimap .

Länge = Anzahl der Zeilen / Spaltenlänge

[0] .length = Anzahl der Spalten / Zeilenlänge

Versuchen Sie dieses folgende Programm für 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));   
    }
}

Mit Java 8, können Sie etwas elegantere wie dies zu tun:

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