행과 열 모두에 대해 2D 배열의 길이를 가져와야합니다. 다음 코드를 사용 하여이 작업을 성공적으로 수행했습니다.

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

예상대로 5, 10이 인쇄됩니다.

이제이 줄을 살펴보십시오.

  int col = test[0].length;

열 길이를 얻으려면 실제로 특정 행을 참조해야합니다. 나에게 이것은 엄청나게 추한 것 같습니다. 또한 배열이 다음과 같이 정의 된 경우 :

test = new int[0][10];

그러면 길이를 얻으려고 할 때 코드가 실패합니다. 이 작업을 수행하는 다른 (보다 지능적인) 방법이 있습니까?

치다

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
}

열 길이는 행마다 다릅니다. 고정 크기 2D 배열로 일부 데이터를 백업하는 경우 래퍼 클래스의 고정 값에 게터를 제공하십시오.

2D 배열은 직사각형 격자가 아닙니다. 또는 Java의 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));
  }
}

출력

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

배열 test과 test2(거의) 동일합니다.

정말 기억하기 힘들었습니다

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

왜 그런지, 그리고 배열 문제가 생겼을 때이를 어떻게 알아낼 수 있는지 이해합시다. 아래 코드에서 행 = 4 및 열 = 3임을 알 수 있습니다.

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

                    {2, 2, 2, 2}, 

                    {3, 3, 3, 3} };

arr여러 배열이 있고 이러한 배열은 세로 방식으로 배열하여 열 수를 얻을 수 있습니다. 행 수를 얻으려면 첫 번째 배열에 액세스하고 길이를 고려해야합니다. 이 경우 [1, 1, 1, 1]에 액세스하여 행 수 = 4가됩니다. 배열을 볼 수없는 문제가 발생하면 배열을 사각형으로 시각화 할 수 있습니다. n X m 차원으로 첫 번째 배열에 액세스 한 다음 길이에 액세스하여 행 수를 얻을 수 있다고 결론을 내립니다. 다른 하나 arr.length는 열에 대한 것입니다.

Java를 사용하면 각 "행"의 길이가 다른 "비정형 배열"을 만들 수 있습니다. 정사각형 배열을 알고 있다면 다음과 같이 빈 배열로부터 보호하기 위해 수정 된 코드를 사용할 수 있습니다.

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

이 배열이있는 경우 :

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

당신은 이것을 할 수 있습니다 :

example.length;

= 2

example[0].length;

= 2

example[1].length;

= 2

example[0][1].length;

= 3

example[1][0].length;

= 4

다차원 배열이 모두 직사각형이 아니기 때문에 언어 수준에서 더 깔끔한 방법은 없습니다. 때때로 들쭉날쭉 한 (서로 다른 열 길이) 배열이 필요합니다.

필요한 기능을 추상화하기 위해 자신 만의 클래스를 쉽게 만들 수 있습니다.

배열에 국한되지 않으면 Multimap 과 같이 다양한 컬렉션 클래스 중 일부가 작동 할 것 입니다.

.length = 행 수 / 열 길이

[0] .length = 열 수 / 행 길이

Java에서 2D 배열에 대해 다음 프로그램을 시도하십시오.

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

을 사용 Java 8하면 다음과 같이 더 우아한 것을 할 수 있습니다.

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