Chcę uzyskać długość tablicy 2D zarówno dla wiersza, jak i dla kolumny. Zrobiłem to pomyślnie, używając następującego kodu:

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

To wypisze 5, 10 zgodnie z oczekiwaniami.

Teraz spójrz na tę linię:

  int col = test[0].length;

Zauważ, że w rzeczywistości muszę odwołać się do określonego wiersza, aby uzyskać długość kolumny. Wydaje mi się to niesamowicie brzydkie. Dodatkowo, jeśli tablica została zdefiniowana jako:

test = new int[0][10];

Wtedy kod nie powiedzie się podczas próby uzyskania długości. Czy istnieje inny (bardziej inteligentny) sposób, aby to zrobić?

Rozważać

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
}

Długości kolumn różnią się w zależności od wiersza. Jeśli tworzysz kopię zapasową niektórych danych za pomocą tablicy 2D o stałym rozmiarze, podaj metody pobierające do stałych wartości w klasie opakowania.

Szyk 2D nie jest prostokątną siatką. A może lepiej, w Javie nie ma czegoś takiego jak tablica 2D.

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

Wyjścia

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

Tablice testi test2są (mniej więcej) takie same.

Naprawdę trudno było to zapamiętać

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

Zrozummy, dlaczego tak jest i jak możemy to rozwiązać, gdy mamy problem z tablicą. Z poniższego kodu widzimy, że wiersze = 4 i kolumny = 3:

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

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arrma wiele tablic, które można ustawić w pionie, aby uzyskać liczbę kolumn. Aby uzyskać liczbę wierszy, musimy uzyskać dostęp do pierwszej tablicy i wziąć pod uwagę jej długość. W tym przypadku uzyskujemy dostęp do [1, 1, 1, 1], a zatem liczba wierszy = 4. Kiedy masz problem, w którym nie możesz zobaczyć tablicy, możesz wizualizować tablicę jako prostokąt z n X m wymiarów i wywnioskować, że możemy uzyskać liczbę wierszy, uzyskując dostęp do pierwszej tablicy, a następnie jej długości. Drugi ( arr.length) dotyczy kolumn.

Java umożliwia tworzenie „nierównych tablic”, w których każdy „wiersz” ma inną długość. Jeśli wiesz, że masz tablicę kwadratową, możesz użyć zmodyfikowanego kodu, aby zabezpieczyć się przed pustą tablicą w następujący sposób:

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

Jeśli masz tę tablicę:

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

Możesz to zrobić:

example.length;

= 2

example[0].length;

= 2

example[1].length;

= 2

example[0][1].length;

= 3

example[1][0].length;

= 4

Nie ma bardziej przejrzystego sposobu na poziomie języka, ponieważ nie wszystkie wielowymiarowe tablice są prostokątne. Czasami potrzebne są tablice postrzępione (o różnych długościach kolumn).

Możesz łatwo utworzyć własną klasę, aby wyodrębnić potrzebną funkcjonalność.

Jeśli nie jesteś ograniczony do tablic, być może niektóre z różnych klas kolekcji również będą działać, na przykład Multimap .

.length = liczba wierszy / długość kolumny

[0] .length = liczba kolumn / długość wiersza

Wypróbuj następujący program dla tablicy 2D w 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));   
    }
}

Dzięki Java 8, możesz zrobić coś bardziej eleganckiego, takiego jak:

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

Możliwe jest również pobranie ilości elementów w wierszu tablicy 2d za pomocą „Arrays.toString (arr [x])” lub całkowitej ilości elementów tablicy 2d / 3d przy użyciu „Arrays.deepToString (arr ) ” . Poda łańcuch składający się ze wszystkich elementów tablicy oddzielonych przecinkami (wiersze są również ograniczone nawiasami kwadratowymi). AND: głównym pomysłem jest to, że całkowita liczba przecinków będzie o 1 mniejsza niż całkowita liczba elementów tablicy / wierszy tablicy! Następnie tworzysz jeszcze jeden ciąg składający się tylko ze wszystkich przecinków (usuwając wszystko inne za pomocą wyrażenia regularnego), a jego długość + 1 będzie wynikiem, którego potrzebujemy. Przykłady:

    public static int getNumberOfElementsIn2DArray() {
    int[][] arr = {
        {1, 2, 3, 1, 452},
        {2, 4, 5, 123, 1, 22},
        {23, 45},
        {1, 122, 33},
        {99, 98, 97},
        {6, 4, 1, 1, 2, 8, 9, 5}
    };
    String str0 = Arrays.deepToString(arr);
    String str = str0.replaceAll("[^,]","");
    return str.length() + 1;
}

Zwróci „27”;

    public static int getNumberOfElementsIn2DArrayRow() {
    int[][] arr = {
        {1, 2, 3, 1, 452},
        {2, 4, 5, 123, 1, 22},
        {23, 45},
        {1, 122, 33},
        {99, 98, 97},
        {6, 4, 1, 1, 2, 8, 9, 5}
    };
    String str0 = Arrays.toString(arr[5]);
    String str = str0.replaceAll("[^,]","");
    return str.length() + 1;
}

Zwróci „8”.

Uwaga! Ta metoda zwróci nieprawidłowy wynik, jeśli twoja tablica wielowymiarowa jest tablicą typu String lub char, w której zawartość elementów zawiera przecinki: D

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