Một nhà kính với các hàng chậu cây#
Hãy hình dung một nhà kính nhỏ có 3 kệ, mỗi kệ có 4 chậu xếp thành hàng. Mỗi sáng một cảm biến đọc độ ẩm đất của từng chậu, từ 0% (khô ran) đến 100% (ướt sũng). Để gọi tên một chậu bạn cần hai con số: kệ nào, rồi chậu nào.
Đó là một mảng hai chiều (mảng 2 chiều): một lưới giá trị trong đó mỗi phần tử được tìm bằng hai chỉ số. Các kệ là các hàng và vị trí chậu là các cột.
| chậu 0 | chậu 1 | chậu 2 | chậu 3 | |
|---|---|---|---|---|
| kệ 0 | 62 | 48 | 55 | 71 |
| kệ 1 | 35 | 41 | 29 | 38 |
| kệ 2 | 80 | 77 | 84 | 69 |
Quy tắc để tới một phần tử là hàng trước, rồi cột: moisture[row][col]. Vậy moisture[1][2] là kệ 1, chậu 2, giá trị 29. Nếu bạn dùng bảng tính, hãy lưu ý sự đảo ngược: một ô bảng tính như C2 gọi cột trước. Trong Java luôn là hàng trước.
Cả hai chỉ số đều bắt đầu từ 0, nên số đọc ở góc trên bên trái là moisture[0][0]. Với 3 kệ, mỗi kệ 4 chậu, chậu ở góc dưới bên phải là moisture[2][3], không phải moisture[3][4].
Khai báo, tạo và điền một lưới#
Bạn đã biết mảng 1 chiều từ bài hướng dẫn về mảng: int[] readings; là kiểu int cộng một cặp ngoặc vuông. Mảng 2 chiều dùng cùng hình dạng đó với một thay đổi: thêm cặp ngoặc vuông thứ hai. int[][] moisture; đọc là “moisture là một mảng của các mảng int”.
Cùng ba bước như trước, từng bước một:
| Bước | Mã | Tác dụng |
|---|---|---|
| 1. Khai báo | int[][] moisture; | tạo một biến có thể trỏ tới một lưới các int. Chưa có lưới nào tồn tại. |
| 2. Tạo | moisture = new int[3][4]; | tạo 3 hàng 4 cột, 12 phần tử. Số hàng đứng trước. Cả hai số đều là số lượng, không phải chỉ số cuối. |
| 3. Điền | moisture[1][2] = 29; | đặt một giá trị vào một phần tử: hàng 1, cột 2. |
Trước khi chạy: sau bước 2, mỗi phần tử trong 12 phần tử chứa gì? Còn trong một String[][] tạo bằng new String[2][3]?
Xem đáp án
Số không trong lưới int và null trong lưới String: giá trị mặc định, giống hệt mảng 1 chiều. Đầu ra bên dưới xác nhận điều đó.
import java.util.Arrays;
public class Greenhouse {
public static void main(String[] args) {
int[][] moisture; // 1. declare
moisture = new int[3][4]; // 2. create: 3 benches, 4 pots on each
System.out.println(Arrays.deepToString(moisture));
moisture[1][2] = 29; // 3. fill: bench 1, pot 2
System.out.println(Arrays.deepToString(moisture));
String[][] plant = new String[2][3];
plant[0][1] = "basil";
System.out.println(Arrays.deepToString(plant));
}
}
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
[[0, 0, 0, 0], [0, 0, 29, 0], [0, 0, 0, 0]]
[[null, basil, null], [null, null, null]]
Arrays.deepToString (từ java.util.Arrays) in cả một lưới, với ngoặc vuông quanh lưới và quanh từng hàng. Nó là phiên bản 2 chiều của Arrays.toString.
Giờ đến dạng ngắn. Nếu bạn đã biết các số đọc, một danh sách khởi tạo làm cả ba bước cùng lúc. Lồng một danh sách trong cho mỗi hàng, bên trong ngoặc nhọn, và Java tự đếm hàng và cột cho bạn:
int[][] moisture = {
{62, 48, 55, 71},
{35, 41, 29, 38},
{80, 77, 84, 69}
};
Mỗi hàng một dòng là quy ước, không phải quy tắc; nó giúp kiểm tra lưới ngay một cái nhìn. Cũng như mảng 1 chiều, dạng ngoặc nhọn trần chỉ dùng được ở dòng khai báo. Ở chỗ khác, hãy viết moisture = new int[][] {{62, 48}, {35, 41}};.
Hai độ dài, và vì sao: một mảng của các mảng#
Mảng 1 chiều có một length. Một lưới có hai kích thước, hàng và cột, và cách bạn hỏi mỗi cái là chi tiết được kiểm tra nhiều nhất trong chủ đề này.
Lý do là Java không có lưới thật sự. Mảng 2 chiều là một mảng mà các phần tử là mảng. Mảng ngoài có một phần tử cho mỗi hàng, và mỗi phần tử đó là một tham chiếu tới cả một hàng: một int[] 1 chiều bình thường.
moisture ---> [ row 0 ] ---> { 62, 48, 55, 71 }
[ row 1 ] ---> { 35, 41, 29, 38 }
[ row 2 ] ---> { 80, 77, 84, 69 }
Vậy moisture.length đếm các phần tử của mảng ngoài: các hàng. Riêng moisture[1] là hàng 1, một int[] hoàn chỉnh, và moisture[1][2] là phần tử 2 của hàng đó.
| Biểu thức | Ý nghĩa | Với ví dụ này |
|---|---|---|
moisture.length | số hàng | 3 |
moisture[r].length | số cột trong hàng r | 4 |
Chương trình dưới đây chép hàng 1 vào một biến, int[] bench1 = moisture[1];, rồi đặt bench1[2] = 60. Sau đó, moisture[1][2] là gì: 29 hay 60?
Xem đáp án
60. bench1 nhận một bản sao của tham chiếu, không phải của hàng. Các hàng được lưu dưới dạng tham chiếu, giống như bài hướng dẫn về mảng đã chỉ ra cho cả mảng, nên cả hai tên cùng tới bốn số đó. Đó cũng là lý do một hàng đơn lẻ có thể được truyền cho bất kỳ phương thức nào nhận một int[].
import java.util.Arrays;
public class Greenhouse {
public static void main(String[] args) {
int[][] moisture = {
{62, 48, 55, 71}, // bench 0
{35, 41, 29, 38}, // bench 1
{80, 77, 84, 69} // bench 2
};
System.out.println("Benches: " + moisture.length);
System.out.println("Pots on bench 0: " + moisture[0].length);
int[] bench1 = moisture[1]; // one whole row, an ordinary int[]
System.out.println(Arrays.toString(bench1));
bench1[2] = 60; // water pot 2 through the row variable
System.out.println(moisture[1][2]);
System.out.println(Arrays.toString(moisture));
System.out.println("Pot 3 on bench 1? " + moisture[3][1]);
}
}
Benches: 3
Pots on bench 0: 4
[35, 41, 29, 38]
60
[[I@7ea987ac, [I@12a3a380, [I@29453f44]
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
at Greenhouse.main(Greenhouse.java:19)
Dòng [[I@... là đầu ra lạ, được hiển thị có chủ đích: Arrays.toString chỉ đi sâu một cấp, nên nó in ba tham chiếu hàng. [I nghĩa là “mảng của int”, và phần sau @ là mã băm sẽ khác khi bạn chạy. Dùng Arrays.deepToString để xem các giá trị.
Dòng cuối đảo chỉ số cho “chậu 3 trên kệ 1”: moisture[3][1]. Nó biên dịch được, rồi ném ArrayIndexOutOfBoundsException. Chỉ số 3 so với độ dài 3 cho bạn biết chỉ số hàng quá lớn.
Mỗi lần bạn viết hai chỉ số, hãy nói trong đầu: “hàng, rồi cột”. Trên bất kỳ lưới nào, chỉ số bị đảo sẽ đọc sai phần tử. Trên lưới không vuông, chúng còn có thể gây sập, như ở đây.
Đi qua mọi chậu bằng vòng lặp lồng nhau#
Để đi qua mọi phần tử bạn cần một vòng lặp lồng nhau: một vòng lặp nằm trong vòng lặp khác. Vòng lặp ngoài chọn một hàng; vòng lặp trong chạy hết cả hàng đó trước khi vòng lặp ngoài chuyển tiếp. Ta gọi các biến vòng lặp là r (hàng, kệ) và c (cột, chậu); bạn sẽ thường thấy các tên này trong bài thi.
public class Greenhouse {
public static void main(String[] args) {
int[][] moisture = {
{62, 48, 55, 71},
{35, 41, 29, 38},
{80, 77, 84, 69}
};
for (int r = 0; r < moisture.length; r++) { // each bench (row)
String line = "Bench " + r + ":";
for (int c = 0; c < moisture[r].length; c++) { // each pot (column) on it
line += " " + moisture[r][c];
}
System.out.println(line);
}
String walk = "Down the pots:";
for (int c = 0; c < moisture[0].length; c++) { // each pot position
for (int r = 0; r < moisture.length; r++) { // each bench
walk += " " + moisture[r][c];
}
}
System.out.println(walk);
}
}
Bench 0: 62 48 55 71
Bench 1: 35 41 29 38
Bench 2: 80 77 84 69
Down the pots: 62 35 80 48 41 77 55 29 84 71 38 69
Cặp vòng lặp đầu là thứ tự theo hàng: vòng ngoài chạy qua hàng, vòng trong chạy qua cột. Nó đọc ngang qua từng kệ, như một trang giấy, và là thứ tự thông thường. Cặp thứ hai là thứ tự theo cột: vòng ngoài chạy qua cột, vòng trong chạy qua hàng, đọc xuống từng vị trí chậu.
Hãy dự đoán trước khi kiểm tra: thứ tự theo cột bắt đầu ở 62, đi xuống 35 và 80, rồi mới chuyển sang chậu 1 (48). Đầu ra bắt đầu bằng 62 35 80 48, từng cột của bảng phía trên một lần, nên nó hợp lý.
Dù cách nào phần tử cũng được viết moisture[r][c], hàng trước; chỉ thứ tự vòng lặp thay đổi. moisture[0].length trong phiên bản theo cột giả định mọi kệ có cùng số chậu.
Cả hai vòng lặp dùng <: r < moisture.length và c < moisture[r].length. Chỉ số hợp lệ cuối cùng luôn là length - 1.
Thu nhỏ về ca nhỏ nhất. Với một kệ một chậu, {{50}}, vòng ngoài chạy với r = 0 và vòng trong với c = 0. Sau đó phép thử bên trong 1 < 1 sai, nên thân chạy đúng một lần. Với <=, nó sẽ chạy lại với c = 1 và ném lỗi. Với không có kệ nào, new int[0][4], phép thử bên ngoài 0 < 0 thất bại ngay và không có gì chạy, điều này cũng đúng.
Tổng theo hàng, tổng theo cột và chậu khô nhất#
Hầu hết câu hỏi thi về mảng 2 chiều dùng một trong ba mẫu: tính tổng mỗi hàng, tính tổng mỗi cột, hoặc tìm phần tử lớn nhất hay nhỏ nhất. Các tổng dùng mẫu bộ tích lũy: bắt đầu ở 0, cộng một giá trị mỗi lần lặp, đọc ở cuối. Câu hỏi mới là bộ tích lũy bắt đầu ở đâu.
Đây là lần thử đầu tiên tính độ ẩm trung bình của mỗi kệ. Trước khi nhìn đầu ra, hãy quyết định giá trị trung bình có thể nằm trong khoảng nào.
Greenhouse.javapublic class Greenhouse {
public static void main(String[] args) {
int[][] moisture = {
{62, 48, 55, 71},
{35, 41, 29, 38},
{80, 77, 84, 69}
};
int benchTotal = 0; // starts once, before the outer loop
for (int r = 0; r < moisture.length; r++) {
for (int c = 0; c < moisture[r].length; c++) {
benchTotal += moisture[r][c];
}
double average = (double) benchTotal / moisture[r].length;
System.out.println("Bench " + r + " average: " + average + "%");
}
}
}
Bench 0 average: 59.0%
Bench 1 average: 94.75%
Bench 2 average: 172.25%
Điều này có hợp lý không? Trung bình của kệ 2 là 172,25%, nhưng không số đọc nào vượt quá 100. Ngay cả chậu ướt nhất cũng không chứa 172% nước. 94.75 của kệ 1 cao hơn mọi chậu trên kệ 1, cũng bất khả thi như vậy. Giá trị trung bình phải nằm giữa giá trị nhỏ nhất và lớn nhất, nên mã sai dù nó đã chạy. Phép kiểm tra năm giây đó cũng quan trọng không kém khi một công cụ AI đưa cho bạn đáp án.
Lỗi: benchTotal bắt đầu ở 0 một lần, trước vòng lặp ngoài, nên tổng của mỗi kệ bao gồm mọi kệ phía trước. Cách sửa dời một dòng: đặt lại bộ tích lũy ở đầu mỗi hàng, bên trong vòng lặp ngoài và trước vòng lặp trong.
public class Greenhouse {
public static void main(String[] args) {
int[][] moisture = {
{62, 48, 55, 71},
{35, 41, 29, 38},
{80, 77, 84, 69}
};
for (int r = 0; r < moisture.length; r++) {
int benchTotal = 0; // reset at the start of every bench
for (int c = 0; c < moisture[r].length; c++) {
benchTotal += moisture[r][c];
}
double average = (double) benchTotal / moisture[r].length;
System.out.println("Bench " + r + " total " + benchTotal + ", average " + average + "%");
}
int driestR = 0;
int driestC = 0;
for (int r = 0; r < moisture.length; r++) {
for (int c = 0; c < moisture[r].length; c++) {
if (moisture[r][c] < moisture[driestR][driestC]) {
driestR = r;
driestC = c;
}
}
}
System.out.println("Driest: " + moisture[driestR][driestC] + "% at bench " + driestR + ", pot " + driestC);
}
}
Bench 0 total 236, average 59.0%
Bench 1 total 143, average 35.75%
Bench 2 total 310, average 77.5%
Driest: 29% at bench 1, pot 2
- Tổng theo hàng: vòng ngoài chạy qua hàng, bộ tích lũy được đặt lại bên trong nó, vòng trong chạy qua các cột của hàng đó.
- Tổng theo cột: tương tự với các vòng lặp đổi chỗ: vòng ngoài chạy qua cột, đặt lại bên trong nó, vòng trong chạy qua hàng. Bạn sẽ tự viết nó bên dưới.
- Phần tử nhỏ nhất: giả sử
moisture[0][0]là khô nhất và để các vòng lặp chứng minh điều ngược lại. Hãy nhớ vị trí (driestR,driestC), không chỉ giá trị, điều này cần vòng lặp đếm. - Tổng cộng: khi vị trí không quan trọng, các vòng lặp for-each lồng nhau cũng dùng được:
for (int[] bench : moisture), rồifor (int reading : bench).
Đừng dán. Hãy viết một phương thức potTotals(int[][] grid) trả về một int[] chứa tổng của mỗi cột: mỗi vị trí chậu, cộng qua tất cả các kệ. Gõ các vòng lặp là cách để thứ tự của r và c ghi nhớ. Giả sử lưới là hình chữ nhật. Hãy kiểm tra nó trên các số đọc ở trên và in kết quả bằng Arrays.toString.
Xem đáp án
Kết quả cần một ô cho mỗi cột, nên kích thước của nó là grid[0].length. Mỗi ô bắt đầu ở 0, nên nó đã là một bộ tích lũy có sẵn:
static int[] potTotals(int[][] grid) {
int[] totals = new int[grid[0].length]; // one total per column
for (int c = 0; c < grid[0].length; c++) {
for (int r = 0; r < grid.length; r++) {
totals[c] += grid[r][c];
}
}
return totals;
}[177, 166, 168, 178]Mọi giá trị trung bình là một phép chia, nên hãy hỏi mỗi vế là kiểu gì. Cả benchTotal và moisture[r].length đều là int, nên nếu không có ép kiểu thì kệ 1 sẽ là 143 / 4, tức là 35. Phép ép kiểu (double) benchTotal đổi tổng thành double trước, nên 35.75 giữ được phần thập phân.
Các kệ có độ dài khác nhau: mảng không đều#
Nhà kính có thêm một kệ góc 2 chậu và một kệ giữa 3 chậu. Một lưới có các hàng khác độ dài là một mảng không đều (ragged hoặc jagged). Nó hoạt động được vì mỗi hàng là một mảng 1 chiều riêng.
Hãy xây từng bước: tạo mảng ngoài chỉ với số hàng, new int[3][], rồi tạo mỗi hàng với kích thước riêng. Chỉ các kích thước sau mới được bỏ, nên new int[][4] không biên dịch được.
import java.util.Arrays;
public class Greenhouse {
public static void main(String[] args) {
int[][] moisture = new int[3][]; // 3 benches, no rows made yet
System.out.println(Arrays.deepToString(moisture));
moisture[0] = new int[] {62, 48, 55, 71};
moisture[1] = new int[] {35, 41}; // the short corner bench
moisture[2] = new int[] {80, 77, 84};
System.out.println(Arrays.deepToString(moisture));
for (int r = 0; r < moisture.length; r++) {
String line = "Bench " + r + " (" + moisture[r].length + " pots):";
for (int c = 0; c < moisture[r].length; c++) {
line += " " + moisture[r][c];
}
System.out.println(line);
}
}
}
[null, null, null]
[[62, 48, 55, 71], [35, 41], [80, 77, 84]]
Bench 0 (4 pots): 62 48 55 71
Bench 1 (2 pots): 35 41
Bench 2 (3 pots): 80 77 84
Hai điều cần để ý:
- Ngay sau
new int[3][], lưới in[null, null, null]: mảng ngoài đã tồn tại, nhưng chưa có hàng nào. Khi đó chạm vàomoisture[0][0]sẽ némNullPointerException. - Vòng lặp an toàn vì vòng trong dùng
moisture[r].length, độ dài của hàng này. Trên lưới không đều,moisture[0].lengthsẽ sai với các hàng khác.
Danh sách khởi tạo cũng dùng được: int[][] moisture = {{62, 48, 55, 71}, {35, 41}, {80, 77, 84}}; xây cùng một lưới.
Truyền một lưới cho phương thức, và trả về một lưới#
Tham số lưới có kiểu int[][], và phương thức nhận một bản sao của tham chiếu, nên nó làm việc trên lưới của nơi gọi. Một phương thức cũng có thể xây một mảng mới và return nó, như rowAverages làm bên dưới với một giá trị trung bình cho mỗi hàng.
import java.util.Arrays;
public class Greenhouse {
static double[] rowAverages(int[][] grid) {
double[] averages = new double[grid.length]; // one slot per row
for (int r = 0; r < grid.length; r++) {
int total = 0;
for (int c = 0; c < grid[r].length; c++) {
total += grid[r][c];
}
averages[r] = (double) total / grid[r].length;
}
return averages;
}
public static void main(String[] args) {
int[][] moisture = {
{62, 48, 55, 71},
{35, 41, 29, 38},
{80, 77, 84, 69}
};
System.out.println(Arrays.toString(rowAverages(moisture)));
int[][] minutesLate = {
{4, 0, 5},
{1, 3}
};
System.out.println(Arrays.toString(rowAverages(minutesLate)));
}
}
[59.0, 35.75, 77.5]
[3.0, 2.0]
rowAverages trả về một double[] với một ô cho mỗi hàng. Vòng lặp trong của nó dùng grid[r].length, nên lưới không đều cũng an toàn.
Hãy nhìn dòng cuối. minutesLate không liên quan gì đến cây trồng: nó chứa việc xe buýt trễ bao nhiêu mỗi chuyến, mỗi tuyến một hàng. rowAverages xử lý nó mà không đổi gì, vì không có gì bên trong nó nói về nhà kính. Đó là lý do nó có tên chung, và vì sao một phương thức có tham số phục vụ được mọi lưới: sổ điểm, thời khóa biểu, bàn cờ.
Ba chiều và hơn nữa#
Giả sử việc kinh doanh lớn lên thành 2 nhà kính, mỗi nhà 3 kệ, mỗi kệ 4 chậu. Một mảng ba chiều (3D) là một mảng của các mảng 2 chiều: site[house][bench][pot]. Mỗi chiều thêm vào thêm một cặp ngoặc vuông, thêm một kích thước sau new và thêm một vòng lặp lồng nhau.
Chương trình dưới đây đánh số mọi chậu 0, 1, 2 và cứ thế theo thứ tự ba vòng lặp đi qua chúng. Số nào rơi vào site[1][2][3]?
Xem đáp án
23. Có 2 × 3 × 4 = 24 chậu, đánh số từ 0 đến 23. site[1][2][3] là chậu cuối trên kệ cuối của nhà kính cuối, nên nó được duyệt cuối cùng.
public class Greenhouse {
public static void main(String[] args) {
int[][][] site = new int[2][3][4]; // 2 houses, 3 benches each, 4 pots per bench
int count = 0;
for (int h = 0; h < site.length; h++) {
for (int r = 0; r < site[h].length; r++) {
for (int c = 0; c < site[h][r].length; c++) {
site[h][r][c] = count; // number each pot in the order it is visited
count++;
}
}
}
System.out.println("Pots: " + count);
System.out.println(site.length + " x " + site[0].length + " x " + site[0][0].length);
System.out.println("House 1, bench 2, pot 3: " + site[1][2][3]);
}
}
Pots: 24
2 x 3 x 4
House 1, bench 2, pot 3: 23
Mỗi .length đọc một cấp: site.length là 2 (nhà kính), site[0].length là 3 (kệ) và site[0][0].length là 4 (chậu). Số phần tử là tích của chúng, 24. Mảng có bốn chiều trở lên là hợp lệ nhưng hiếm.
Điều mới trong bài hướng dẫn này#
int[][]: kiểu 1 chiều cộng cặp ngoặc vuông thứ hai.new int[3][4]và các danh sách khởi tạo lồng nhau, số hàng đứng trước.moisture[r][c]: hàng trước, rồi cột, cả hai từ 0.moisture.lengthđếm hàng;moisture[r].lengthđếm số cột của hàng đó.- Mỗi hàng là một
int[]bình thường, được lưu dưới dạng tham chiếu dùng chung. - Vòng lặp lồng nhau theo thứ tự hàng hoặc cột.
- Tổng theo hàng, tổng theo cột và tìm phần tử nhỏ nhất.
- Mảng không đều:
new int[3][], rồi từng hàng riêng. - Truyền một lưới cho phương thức, và trả về một mảng.
- Mảng 3 chiều, và
Arrays.deepToStringđể in bất kỳ lưới nào.
Mảng 2 chiều là một mảng của các hàng: grid[r][c] là hàng trước, grid.length đếm hàng, và grid[r].length đếm số cột của hàng r. Vòng ngoài chạy qua hàng đọc theo chiều ngang, và vòng ngoài chạy qua cột đọc theo chiều dọc. Tổng của hàng được đặt lại bên trong vòng ngoài, trước vòng trong.
Những chỗ dễ sai#
- Đảo chỉ số. Nó là
grid[row][col]. Trên bất kỳ lưới nào, chỉ số bị đảo đọc sai phần tử. Trên lưới không vuông, chúng còn có thể gây sập. - Dùng sai độ dài.
grid.lengthlà số hàng; số cột làgrid[r].length. Trên mảng không đều,grid[0].lengthsai với các hàng khác, nên hãy dùnggrid[r].lengthtrong vòng trong. - Bắt đầu tổng hàng ở ngoài vòng lặp ngoài. Khi đó tổng của mỗi hàng bao gồm mọi hàng phía trước. Hãy đặt lại nó bên trong vòng lặp ngoài.
- Chia hai int để tính trung bình.
143 / 4là 35. Hãy ép một vế sangdoubletrước. - In mảng 2 chiều bằng
Arrays.toString. Bạn nhận các tham chiếu hàng như[I@và một mã băm. Hãy dùngArrays.deepToString. - Viết
new int[][4]. Số hàng phải đứng trước; chỉ các kích thước sau mới được bỏ. - Đọc một hàng của
new int[3][]trước khi tạo nó. Hàng lànullcho đến khi bạn tạo, nên việc đọc némNullPointerException.
Trong bài thi: nếu một câu hỏi nói “viết một phương thức”, chỉ viết phương thức: phần đầu, thân và return của nó. Nếu nói “viết một chương trình”, hãy bao gồm lớp và main. Với câu hỏi mảng 2 chiều, điểm từng phần thường nằm ở phần đầu của các vòng lặp. Hãy viết chúng cẩn thận: đúng độ dài trong từng vòng, và < thay vì <=. Đọc câu hỏi, đọc lại, trả lời, rồi đọc thêm một lần nữa để kiểm tra bạn đã làm mọi phần.
Luyện tập#
Hãy trả lời từng câu trên giấy trước khi xem lời giải. Mọi đáp án có chạy mã đều đã được kiểm tra bằng cách biên dịch và chạy mã đó.
- Với
int[][] g = new int[4][6];,g.length,g[0].length, số phần tử, và chỉ số của phần tử góc dưới bên phải là gì? - Chương trình in ra gì?
int[][] m = new int[3][2]; for (int r = 0; r < m.length; r++) { for (int c = 0; c < m[r].length; c++) { m[r][c] = r * 10 + c; } } System.out.println(m.length + " " + m[0].length); System.out.println(m[2][1]); System.out.println(m[1][0] + m[0][1]); - Viết một phương thức trả về tổng đường chéo chính của một mảng 2 chiều vuông: các phần tử mà chỉ số hàng bằng chỉ số cột.
- Cho một lưới 3 hàng 5 cột, thân vòng lặp trong chạy bao nhiêu lần khi duyệt đầy đủ theo hàng? Còn khi duyệt đầy đủ theo cột?
- Viết một phương thức đếm số số không trong một mảng 2 chiều mà các hàng có thể có độ dài khác nhau.
new double[2][5][10]tạo bao nhiêu phần tử, và bạn đọc kích thước của chiều cuối như thế nào?
Lời giải#
g.lengthlà 4 (hàng),g[0].lengthlà 6 (cột), có 24 phần tử, và phần tử góc dưới bên phải làg[3][5].- Mỗi phần tử bằng mười lần hàng của nó cộng với cột của nó, nên
m[2][1]là 21, vàm[1][0] + m[0][1]là 10 + 1:public class QTrace { public static void main(String[] args) { int[][] m = new int[3][2]; for (int r = 0; r < m.length; r++) { for (int c = 0; c < m[r].length; c++) { m[r][c] = r * 10 + c; } } System.out.println(m.length + " " + m[0].length); System.out.println(m[2][1]); System.out.println(m[1][0] + m[0][1]); } }3 2 21 11 - Chỉ cần một vòng lặp, vì hàng và cột di chuyển cùng nhau:
public class QDiag { public static int diagonalSum(int[][] sq) { int sum = 0; for (int i = 0; i < sq.length; i++) { sum += sq[i][i]; } return sum; } public static void main(String[] args) { int[][] sq = { {2, 0, 1}, {5, 3, 9}, {4, 6, 7} }; System.out.println(diagonalSum(sq)); } }
Với lưới đã cho, đường chéo là 2 + 3 + 7 = 12.12 - Cả hai lần đều 15: mỗi phần tử được duyệt đúng một lần. Duyệt theo hàng chạy vòng ngoài 3 lần với 5 lần lặp trong mỗi lần; duyệt theo cột chạy vòng ngoài 5 lần với 3 lần lặp trong mỗi lần.
- Các vòng lặp for-each lồng nhau không bao giờ cần độ dài nào, nên an toàn trên mảng không đều:
public class QCount { public static int countZeros(int[][] g) { int zeros = 0; for (int[] row : g) { for (int x : row) { if (x == 0) { zeros++; } } } return zeros; } public static void main(String[] args) { int[][] g = { {0, 3}, {1, 0, 0}, {7} }; System.out.println(countZeros(g)); } }3 - 2 × 5 × 10 = 100 phần tử, tất cả bắt đầu ở 0.0. Kích thước của chiều cuối là
arr[0][0].length, tức là 10.
Danh sách kiểm tra trước khi thi#
Đây là các mục trong danh sách chủ đề Bài thi 2 của môn học mà bài hướng dẫn này đề cập. Chỉ đánh dấu mỗi mục khi bạn làm được mà không cần nhìn.
- ☐ Tôi có thể tạo và khởi tạo một mảng hai chiều và tới bất kỳ phần tử nào bằng
[row][col]. - ☐ Tôi có thể phân biệt
grid.lengthvớigrid[r].lengthvà giải thích vì sao mảng 2 chiều là một mảng của các mảng. - ☐ Tôi có thể duyệt mảng 2 chiều theo hàng và theo cột, và tính tổng theo hàng và theo cột.
- ☐ Tôi có thể làm việc với mảng không đều và mảng nhiều chiều từ ba chiều trở lên.
Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí
40 câu hỏi luyện tập về mảng 2 chiều, mảng không đều và mảng nhiều chiều, mọi đáp án mã đều được kiểm tra bằng cách biên dịch và chạy. Miễn phí, dùng được khi không có mạng, không cần tài khoản.
Luyện tập mảng 2 chiều →Câu hỏi thường gặp#
Làm sao khai báo một mảng 2 chiều trong Java?
Dùng hai cặp ngoặc vuông: int[][] grid = new int[3][4]; tạo 3 hàng 4 cột, mọi phần tử bắt đầu bằng 0. Để điền ngay, hãy lồng các danh sách khởi tạo, mỗi hàng một danh sách trong: int[][] grid = {{1, 2}, {3, 4}};.
Trong mảng 2 chiều, chỉ số nào đứng trước, hàng hay cột?
Hàng. grid[r][c] nghĩa là hàng r, cột c, và cả hai chỉ số đều bắt đầu từ 0.
Làm sao lấy số hàng và số cột của một mảng 2 chiều?
grid.length là số hàng. grid[r].length là số cột của hàng r. Với mảng hình chữ nhật, mọi hàng đều có cùng độ dài, nên grid[0].length cho số cột.
Mảng không đều (ragged, jagged) là gì?
Một mảng 2 chiều có các hàng với độ dài khác nhau. Nó hoạt động được vì mảng 2 chiều là một mảng của các mảng hàng 1 chiều riêng biệt. Hãy tạo nó chỉ với số hàng, như new int[4][], rồi tạo từng hàng riêng.
Duyệt theo hàng (row-major) và theo cột (column-major) khác nhau thế nào?
Thứ tự theo hàng dùng vòng lặp ngoài cho hàng và vòng lặp trong cho cột, nên đọc ngang qua từng hàng. Thứ tự theo cột đổi chỗ các vòng lặp và đọc xuống từng cột. Dù cách nào, phần tử vẫn được viết grid[r][c].
Làm sao in một mảng 2 chiều trong Java?
Dùng Arrays.deepToString(grid) từ java.util.Arrays, hoặc các vòng lặp lồng nhau. Arrays.toString trên mảng 2 chiều in tham chiếu của các mảng hàng chứ không phải giá trị của chúng.
Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.