Cú pháp tạo mảng hai chiều

Xem xét:

int[][] multD = new int[5][];
multD[0] = new int[10];

Đây có phải là cách bạn tạo một mảng hai chiều với 5 hàng và 10 cột không?

Tôi thấy mã này trực tuyến, nhưng cú pháp không có ý nghĩa.

Hãy thử như sau:

int[][] multi = new int[5][10];

... đó là một bàn tay ngắn cho một cái gì đó như thế này:

int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];

Lưu ý rằng tất cả các phần tử sẽ được khởi tạo với giá trị mặc định cho int, 0, vì vậy ở trên cũng tương đương với:

int[][] multi = new int[][]{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

Chúng ta có thể khai báo một mảng hai chiều và lưu trữ trực tiếp các phần tử tại thời điểm khai báo là:

int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

Ở đây int đại diện cho các phần tử kiểu nguyên được lưu trữ trong mảng và tên mảng là 'mark'. int là kiểu dữ liệu cho tất cả các phần tử được biểu diễn bên trong dấu ngoặc "{" và "}" vì một mảng là tập hợp các phần tử có cùng kiểu dữ liệu.

Quay trở lại với tuyên bố của chúng tôi được viết ở trên: mỗi hàng của các yếu tố nên được viết bên trong dấu ngoặc nhọn. Các hàng và các thành phần trong mỗi hàng phải được phân tách bằng dấu phẩy.

Bây giờ hãy quan sát câu lệnh: bạn có thể nhận được có 3 hàng và 5 cột, do đó JVM tạo ra 3 * 5 = 15 khối bộ nhớ. Các khối này có thể được gọi riêng lẻ như:

marks[0][0]  marks[0][1]  marks[0][2]  marks[0][3]  marks[0][4]
marks[1][0]  marks[1][1]  marks[1][2]  marks[1][3]  marks[1][4]
marks[2][0]  marks[2][1]  marks[2][2]  marks[2][3]  marks[2][4]

LƯU Ý:
Nếu bạn muốn lưu trữ n phần tử thì chỉ mục mảng bắt đầu từ 0 và kết thúc tại n-1 . Một cách khác để tạo một mảng hai chiều là bằng cách khai báo mảng trước và sau đó phân bổ bộ nhớ cho nó bằng cách sử dụng toán tử mới.

int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

Bằng cách kết hợp hai điều trên chúng ta có thể viết:

int marks[][] = new int[3][5];

Bạn có thể tạo chúng theo cách mà người khác đã đề cập. Thêm một điểm nữa để thêm: Bạn thậm chí có thể tạo một mảng hai chiều bị lệch với mỗi hàng, không nhất thiết phải có cùng số lượng collumns, như thế này:

int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];

Thành ngữ phổ biến nhất để tạo một mảng hai chiều với 5 hàng và 10 cột là:

int[][] multD = new int[5][10];

_{Ngoài ra, bạn có thể sử dụng cách sau, tương tự như những gì bạn có, mặc dù bạn cần khởi tạo rõ ràng từng hàng:}

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
  multD[i] = new int[10];
}

Cũng có thể khai báo theo cách sau. Nó không phải là thiết kế tốt, nhưng nó hoạt động.

int[] twoDimIntArray[] = new int[5][10];

Thử:

int[][] multD = new int[5][10];

Lưu ý rằng trong mã của bạn chỉ có dòng đầu tiên của mảng 2D được khởi tạo thành 0. Dòng 2 đến 5 thậm chí không tồn tại. Nếu bạn cố in chúng, bạn sẽ nhận được nullcho mọi người trong số họ.

int [][] twoDim = new int [5][5];

int a = (twoDim.length);//5
int b = (twoDim[0].length);//5

for(int i = 0; i < a; i++){ // 1 2 3 4 5
    for(int j = 0; j <b; j++) { // 1 2 3 4 5
        int x = (i+1)*(j+1);
        twoDim[i][j] = x;
        if (x<10) {
            System.out.print(" " + x + " ");
        } else {
            System.out.print(x + " ");
        }
    }//end of for J
    System.out.println();
}//end of for i

Trong Java, một mảng hai chiều có thể được khai báo giống như một mảng một chiều. Trong một mảng một chiều, bạn có thể viết như

  int array[] = new int[5];

Trong đó int là kiểu dữ liệu, mảng [] là khai báo mảng và new arraylà mảng có các đối tượng có năm chỉ mục.

Như vậy, bạn có thể viết một mảng hai chiều như sau.

  int array[][];
  array = new int[3][4];

Đây arraylà một kiểu dữ liệu int. Trước tiên tôi đã khai báo trên một mảng một chiều của các loại đó, sau đó một mảng 3 hàng và 4 cột được tạo.

Trong mã của bạn

int[][] multD = new int[5][];
multD[0] = new int[10];

có nghĩa là bạn đã tạo một mảng hai chiều, với năm hàng. Trong hàng đầu tiên có 10 cột. Trong Java, bạn có thể chọn kích thước cột cho mỗi hàng theo ý muốn.

int rows = 5;
int cols = 10;

int[] multD = new int[rows * cols];

for (int r = 0; r < rows; r++)
{
  for (int c = 0; c < cols; c++)
  {
     int index = r * cols + c;
     multD[index] = index * 2;
  }
}

Thưởng thức!

Hãy thử cách này:

int a[][] = {{1,2}, {3,4}};

int b[] = {1, 2, 3, 4};

Các loại mảng này được gọi là mảng răng cưa trong Java:

int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];

Trong kịch bản này, mỗi hàng của mảng chứa số cột khác nhau. Trong ví dụ trên, hàng đầu tiên sẽ giữ ba cột, hàng thứ hai sẽ giữ hai cột và hàng thứ ba chứa năm cột. Bạn có thể khởi tạo mảng này tại thời gian biên dịch như dưới đây:

 int[][] multD = {{2, 4, 1}, {6, 8}, {7, 3, 6, 5, 1}};

Bạn có thể dễ dàng lặp lại tất cả các yếu tố trong mảng của mình:

for (int i = 0; i<multD.length; i++) {
    for (int j = 0; j<multD[i].length; j++) {
        System.out.print(multD[i][j] + "\t");
    }
    System.out.println();
}

Thật ra Java không có mảng đa chiều theo nghĩa toán học. Những gì Java có chỉ là mảng các mảng, một mảng trong đó mỗi phần tử cũng là một mảng. Đó là lý do tại sao yêu cầu tuyệt đối để khởi tạo nó là kích thước của kích thước đầu tiên. Nếu phần còn lại được chỉ định thì nó sẽ tạo ra một mảng được điền với giá trị mặc định.

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

Nó cũng cho chúng ta một sự giải quyết. Kích thước của mảng con không thể thay đổi bằng cách thêm nhiều phần tử, nhưng chúng ta có thể làm như vậy bằng cách gán một mảng mới có kích thước tùy ý.

int[][]   ar  = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1]    = new int[] {1,2,3,4,5,6}; // works