Một danh sách chờ có các dòng đánh số#
Hãy hình dung tờ giấy kẹp trên bảng ở quầy đón khách của một quán ăn đông khách. Tờ giấy có sáu dòng in sẵn. Mỗi dòng chứa cùng một loại thứ, một nhóm khách đang chờ, và người đón khách có thể chỉ vào bất kỳ dòng nào bằng số của nó. Bạn không thể thêm dòng thứ bảy vào một tờ giấy đã in.
Mảng trong Java chính là tờ giấy đó. Mỗi dòng gọi là một phần tử, và số của nó là chỉ số. Cả bài hướng dẫn này xây dựng một chương trình nhỏ, Waitlist, cho quán ăn đó. Mỗi phần thêm một ý vào chương trình, và mỗi bước cho thấy đầu ra thật.
Mọi chỉ số đều bắt đầu từ 0. Một tờ giấy 6 dòng có các chỉ số từ 0 đến 5, nên dòng thứ sáu là chỉ số 5, không phải 6.
Khai báo, tạo và điền giá trị#
Bạn đã biết cách tạo một biến: kiểu, rồi tên, như int partySize;. Mảng dùng cùng hình thức đó với một thay đổi: dấu ngoặc vuông sau kiểu. int[] party; đọc là “party là một mảng các int”.
Tạo một mảng dùng được cần ba bước. Hãy học từng bước một trước; dạng ngắn gọn sẽ đến sau.
| Bước | Mã | Tác dụng |
|---|---|---|
| 1. Khai báo | int[] party; | tạo một biến có thể trỏ tới một mảng các int. Chưa có mảng nào tồn tại. |
| 2. Tạo | party = new int[6]; | dành chỗ cho 6 int và cho biến trỏ tới đó. Số 6 là số lượng, không phải chỉ số cuối. |
| 3. Khởi tạo giá trị | party[0] = 4; | điền một giá trị vào một phần tử, dùng dấu ngoặc vuông và một chỉ số. Việc này gọi là khởi tạo giá trị cho nó. |
Trước khi chạy: một tờ giấy mới tinh chưa có tên nào trên đó. Bạn nghĩ Java đặt gì vào mỗi phần tử của new int[6]? Còn trong mỗi phần tử của new String[6]?
Xem đáp án
Số không trong mảng int, và null trong mảng String. Java không bao giờ để một phần tử có giá trị ngẫu nhiên; nó điền cho mỗi phần tử một giá trị mặc định. Hãy chạy chương trình dưới đây để kiểm tra.
import java.util.Arrays;
public class Waitlist {
public static void main(String[] args) {
int[] party; // declare: a variable for an array of ints
party = new int[6]; // create: six lines, numbered 0 to 5
String[] names = new String[6];
System.out.println(Arrays.toString(party));
System.out.println(Arrays.toString(names));
party[0] = 4; // fill: line 0 gets a party of 4
names[0] = "Ortiz";
System.out.println(Arrays.toString(party));
System.out.println(Arrays.toString(names));
}
}
[0, 0, 0, 0, 0, 0]
[null, null, null, null, null, null]
[4, 0, 0, 0, 0, 0]
[Ortiz, null, null, null, null, null]
Số bắt đầu bằng 0 (hoặc 0.0), boolean bắt đầu bằng false, và bất cứ thứ gì là đối tượng, kể cả String, bắt đầu là null, nghĩa là “chưa trỏ tới gì”. Arrays.toString (từ java.util.Arrays) biến cả mảng thành một String nằm trong dấu ngoặc vuông, và println in String đó ra.
Bây giờ là các dạng ngắn gọn. Bước 1 và 2 vừa trong một dòng: int[] party = new int[6];. Và nếu bạn đã biết các giá trị, một danh sách khởi tạo làm cả ba bước cùng lúc và đếm số phần tử giúp bạn: int[] party = {4, 2, 5, 3};. Dạng ngoặc nhọn chỉ dùng được ở dòng khai báo biến. Ở bất kỳ chỗ nào khác, hãy viết party = new int[] {4, 2, 5, 3};.
length, và việc bước ra khỏi cuối mảng#
Mọi mảng đều biết kích thước của mình qua length. Nó là một trường, một giá trị lưu cùng với mảng, không phải phương thức, nên không có dấu ngoặc đơn: party.length. Chuỗi dùng phương thức s.length(), có dấu ngoặc đơn, và ArrayList dùng size(). Nhầm lẫn những cái này là một lỗi biên dịch kinh điển.
Giờ chương trình bắt đầu từ bốn nhóm khách đang chờ:
Waitlist.javapublic class Waitlist {
public static void main(String[] args) {
int[] party = {4, 2, 5, 3};
System.out.println(party.length);
System.out.println(party[0]);
System.out.println(party[party.length - 1]);
System.out.println(party[4]);
}
}
4
4
3
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
at Waitlist.main(Waitlist.java:7)
Các chỉ số hợp lệ chạy từ 0 đến length - 1, nên nhóm cuối cùng là party[party.length - 1]. Yêu cầu chỉ số 4 trong một mảng có độ dài 4 vẫn biên dịch được, rồi dừng chương trình với ArrayIndexOutOfBoundsException. Hãy đọc thông báo: nó cho bạn cả hai con số, chỉ số bạn yêu cầu và độ dài bạn có.
Duyệt qua từng phần tử#
Người đón khách muốn hai con số: tổng cộng có bao nhiêu khách đang chờ, và quy mô trung bình của một nhóm.
Các nhóm là 4, 2, 5 và 3. Hãy tự tính tổng và trung bình trước khi đọc mã.
Xem đáp án
Tổng là 14 và trung bình là 3,5. Hãy nhớ số 3,5 đó cho đầu ra tiếp theo.
public class Waitlist {
public static void main(String[] args) {
int[] party = {4, 2, 5, 3};
int total = 0; // the accumulator starts at 0
for (int guests : party) {
total += guests; // and grows by one value per pass
}
System.out.println("Guests waiting: " + total);
System.out.println("Average party: " + total / party.length);
}
}
Guests waiting: 14
Average party: 3
Tổng đúng. Tổng chạy trong total được gọi là mẫu bộ cộng dồn (accumulator): bắt đầu một biến ở 0 trước vòng lặp, cộng một giá trị vào nó ở mỗi lượt, và đọc nó sau khi vòng lặp kết thúc.
Trung bình thì không đúng. 3 có hợp lý không? Bạn đã dự đoán 3,5. Đáp án phải nằm giữa nhóm nhỏ nhất (2) và nhóm lớn nhất (5), nên 3 là có thể. Chính vì vậy một đáp án sai như thế này lọt qua khi không ai dự đoán trước. Việc kiểm tra tương tự cũng quan trọng khi một công cụ hoặc AI đưa cho bạn câu trả lời: ước chừng trước xem nó nên là bao nhiêu, rồi so sánh.
Mỗi lần chia, hãy dừng lại và hỏi mỗi vế có kiểu gì. total là một int và party.length là một int, nên 14 / 4 là phép chia số nguyên và bỏ mất .5. Hãy biến một vế thành double trước bằng một phép ép kiểu, chuyển một giá trị sang kiểu khác: (double) total / party.length.
Với một thay đổi đó ở dòng cuối:
Guests waiting: 14
Average party: 3.5
Vòng lặp ở trên là vòng lặp for-each: for (int guests : party) đọc là “với mỗi int guests trong party”. Đó là cách ngắn gọn khi bạn chỉ cần từng giá trị. Khi bạn cần biết giá trị nằm ở đâu, hãy dùng vòng lặp for đếm. Nó có bốn phần: khởi tạo (int i = 1), điều kiện (i < party.length), cập nhật (i++) và thân bên trong dấu ngoặc nhọn.
public class Waitlist {
public static void main(String[] args) {
int[] party = {4, 2, 5, 3};
int biggest = 0; // index of the biggest party so far
for (int i = 1; i < party.length; i++) {
if (party[i] > party[biggest]) {
biggest = i;
}
}
System.out.println("Biggest: " + party[biggest] + " on line " + biggest);
for (int guests : party) {
guests = 0; // changes the copy, not the array
}
System.out.println("Line 0 still holds " + party[0]);
}
}
Biggest: 5 on line 2
Line 0 still holds 4
Phần tìm kiếm giả định dòng 0 là lớn nhất (biggest giữ một chỉ số) và để vòng lặp chứng minh điều ngược lại từ chỉ số 1. Nếu bắt đầu với giá trị lớn nhất bằng 0 thì sẽ cho đáp án sai khi mọi giá trị đều âm. Vòng lặp thứ hai cho thấy giới hạn của for-each: guests là bản sao của từng giá trị, nên đặt nó bằng 0 chỉ đổi bản sao và để nguyên mảng. Để thay đổi phần tử, hãy dùng vòng lặp đếm và viết party[i] = ....
Thu nhỏ về trường hợp nhỏ nhất. Để kiểm tra điều kiện vòng lặp, hãy thu nhỏ mảng đến khi bạn dò được trong đầu. Với một nhóm, {4}, vòng lặp for (int i = 0; i < party.length; i++) chạy với i = 0, rồi kiểm tra 1 < 1, là sai, nên nó chạy đúng một lần. Nếu viết với i <= party.length, nó sẽ chạy lần thứ hai với i = 1 và ném lỗi. Một phần tử là đủ nhỏ để chắc chắn.
Một quy ước đáng áp dụng: hãy viết i < party.length thay vì i <= party.length - 1. Cả hai đều đúng, nhưng cách đầu cho thấy trực tiếp số lượng và ít hơn một chỗ để sai. Nếu bạn thích cách thứ hai, đó không phải là lỗi.
Mảng được lưu dưới dạng tham chiếu#
Biến mảng không giữ các phần tử. Nó giữ một tham chiếu: một mũi tên trỏ tới nơi các phần tử nằm. Ở quán ăn, quầy đón khách và màn hình nhà bếp hiển thị cùng một danh sách. Đổi ở bên này thì bên kia thấy thay đổi, vì chỉ có một danh sách.
Waitlist.javaimport java.util.Arrays;
public class Waitlist {
public static void main(String[] args) {
int[] party = {4, 2, 5, 3};
int[] kitchenView = party; // a second arrow to the same list
kitchenView[1] = 3; // the party on line 1 grew by one
System.out.println(Arrays.toString(party));
int[] snapshot = Arrays.copyOf(party, party.length);
snapshot[0] = 9;
System.out.println(Arrays.toString(party));
System.out.println(Arrays.toString(snapshot));
int[] same = {4, 3, 5, 3};
System.out.println(party == same);
System.out.println(Arrays.equals(party, same));
System.out.println(party);
}
}
[4, 3, 5, 3]
[4, 3, 5, 3]
[9, 3, 5, 3]
false
true
[I@659e0bfd
kitchenView = party sao chép mũi tên, không phải danh sách, nên đổi kitchenView[1] làm thay đổi điều party thấy. Arrays.copyOf tạo một danh sách thứ hai thật sự, nên đổi snapshot không ảnh hưởng đến party. Khi so sánh, == hỏi “cùng một danh sách không?” còn Arrays.equals hỏi “cùng giá trị theo cùng thứ tự không?”.
Dòng cuối được cho xem có chủ ý, vì bạn sẽ gặp nó. In chính biến mảng không in ra các giá trị. [I@659e0bfd là kiểu của mảng và một mã băm (hash code): [ nghĩa là “mảng”, I nghĩa là int, và phần sau @ là một số Java dùng để nhận diện đối tượng. Khi bạn chạy, nó sẽ khác. Thấy nó nghĩa là “bạn đã in tham chiếu”; hãy dùng Arrays.toString để xem nội dung.
Truyền một mảng cho phương thức, và trả về một mảng#
Java truyền mọi đối số dưới dạng bản sao giá trị của nó, gọi là truyền theo giá trị (pass-by-value). Với mảng, giá trị đó là mũi tên. Vì vậy một phương thức có thể thay đổi các phần tử của mảng của bên gọi, nhưng cho bản sao của mình trỏ sang một mảng mới thì không có tác dụng gì với bên gọi.
Trong chương trình dưới đây, clearBoard đặt tham số của nó thành một mảng rỗng hoàn toàn mới. Sau lời gọi, waitlist của bên gọi có rỗng không?
Xem đáp án
Không. Phương thức chuyển bản sao mũi tên của nó sang một mảng mới. Mũi tên của bên gọi vẫn trỏ tới danh sách gốc, nên nó in lại [4, 2, 5, 4].
import java.util.Arrays;
public class Waitlist {
public static void addGuests(int[] party, int line, int extra) {
party[line] += extra;
}
public static void clearBoard(int[] party) {
party = new int[6];
}
public static int[] bigParties(int[] party, int min) {
int count = 0;
for (int guests : party) {
if (guests >= min) {
count++;
}
}
int[] result = new int[count];
int next = 0;
for (int guests : party) {
if (guests >= min) {
result[next] = guests;
next++;
}
}
return result;
}
public static void main(String[] args) {
int[] party = {4, 2, 5, 3};
addGuests(party, 3, 1);
System.out.println(Arrays.toString(party));
clearBoard(party);
System.out.println(Arrays.toString(party));
System.out.println(Arrays.toString(bigParties(party, 4)));
}
}
[4, 2, 5, 4]
[4, 2, 5, 4]
[4, 5, 4]
addGuests đã thay đổi một phần tử, và thay đổi đó được giữ lại. clearBoard không thay đổi điều gì mà bên gọi thấy được. bigParties cho thấy cách trả về một mảng mới: dựng nó bên trong, rồi return nó. Kiểu trả về int[] cho biết phương thức trả về một mảng các int. Nó làm trong hai lượt duyệt, một lượt đếm xem kết quả phải lớn bao nhiêu và một lượt điền vào, vì kích thước mảng là cố định một khi đã tạo.
Hãy để ý rằng không có gì bên trong bigParties thực sự nói về khách quán ăn. Đưa cho nó số chỗ ngồi của một chiếc xe buýt, điểm số của một trò chơi hay số trang của một cuốn sách, nó vẫn trả về các giá trị bằng hoặc lớn hơn min. Một phương thức, viết một lần, dùng được cho mọi mảng của kiểu đó. Vì vậy, ngoài một ví dụ có chủ đề như thế này, tham số mảng thường được đặt tên chung như values hay nums; party ở đây chỉ để phục vụ câu chuyện.
Mảng bạn đã gõ từ chương trình đầu tiên#
Mọi chương trình bạn đã viết đều bắt đầu bằng public static void main(String[] args). Giờ bạn đọc được phần cuối: args là một mảng các String. Khi bạn chạy chương trình từ terminal, mọi từ bạn gõ sau tên lớp được đặt vào đó, mỗi từ một phần tử.
public class Waitlist {
public static void main(String[] args) {
System.out.println("Arguments: " + args.length);
if (args.length > 0) {
int first = Integer.parseInt(args[0]);
System.out.println("First party: " + first + " guests");
System.out.println("As text, doubled: " + args[0] + args[0]);
System.out.println("As a number, doubled: " + (first + first));
}
}
}
Chạy với hai đối số, rồi không có đối số nào:
$ java Waitlist 4 2
Arguments: 2
First party: 4 guests
As text, doubled: 44
As a number, doubled: 8
$ java Waitlist
Arguments: 0
args[0] là String "4", không phải số 4, dù bạn gõ một chữ số. Đó là lý do “nhân đôi” nó như văn bản đã nối nó với chính nó và cho 44. Integer.parseInt biến văn bản thành một int. Khi không có đối số, args.length bằng 0, đó là lý do chương trình kiểm tra nó trước khi chạm vào args[0]. Nút Run của trình soạn thảo thường chạy main với một mảng rỗng, nên việc kiểm tra cũng quan trọng ở đó.
Mảng vừa đủ và mảng lớn hơn mức cần dùng#
Mảng không thể lớn lên, nên có hai cách dùng nó:
- Mảng vừa đủ (perfect-size) có đúng số phần tử bằng số mục, nên
lengthlà số lượng mục. Nó phù hợp với dữ liệu mà bạn biết trước số lượng. - Mảng lớn hơn mức cần dùng (oversized) được tạo lớn hơn bạn cần, và một
intriêng, thường gọi làsizehoặccount, nhớ có bao nhiêu phần tử đang dùng. Nó phù hợp với các mục đến rồi đi.
Tờ giấy kẹp của quán ăn thuộc loại lớn hơn mức cần dùng: 6 dòng in sẵn, nhưng tại mỗi thời điểm chỉ một số dòng có chữ. Các nhóm đang dùng luôn được dồn ở phía trước, ở chỉ số từ 0 đến size - 1, và mọi thứ sau đó là chỗ trống dự phòng. Đây là mẫu mảng lớn hơn mức cần dùng kèm một số đếm, và quy tắc duy nhất của nó là: mọi vòng lặp dừng ở size, không phải ở length.
Thêm, tìm và xóa trong mảng lớn hơn mức cần dùng#
Đây là danh sách chờ dưới dạng danh sách tên, với ba thao tác được viết thành các phương thức dùng chung mảng và số đếm của nó. Hãy đọc chúng như một bộ.
Danh sách có Ortiz, Lee, Patel và Nguyen. Lee đã được xếp chỗ ngồi, nên remove("Lee") chạy. Hãy viết ra danh sách và size mới trước khi nhìn đầu ra.
Xem đáp án
Ortiz, Patel, Nguyen, với size bằng 3. Patel và Nguyen mỗi người trượt lên một dòng để lấp khoảng trống.
public class Waitlist {
static String[] names = new String[6]; // the clipboard: 6 lines
static int size = 0; // how many lines are in use
static boolean add(String name) {
if (size == names.length) {
return false; // clipboard full
}
names[size] = name; // first empty line
size++;
return true;
}
static int find(String name) {
for (int i = 0; i < size; i++) { // stop at size, not length
if (names[i].equals(name)) {
return i;
}
}
return -1; // not on the list
}
static boolean remove(String name) {
int at = find(name);
if (at == -1) {
return false;
}
for (int i = at; i < size - 1; i++) {
names[i] = names[i + 1]; // slide each later name up
}
size--;
return true;
}
static void show() {
String line = "size " + size + ":";
for (int i = 0; i < size; i++) {
line += " " + names[i];
}
System.out.println(line);
}
public static void main(String[] args) {
add("Ortiz");
add("Lee");
add("Patel");
add("Nguyen");
show();
System.out.println("Lee is on line " + find("Lee"));
System.out.println("Kim is on line " + find("Kim"));
remove("Lee");
show();
add("Kim");
add("Adams");
add("Brooks");
show();
System.out.println("Room for Cho? " + add("Cho"));
}
}
size 4: Ortiz Lee Patel Nguyen
Lee is on line 1
Kim is on line -1
size 3: Ortiz Patel Nguyen
size 6: Ortiz Patel Nguyen Kim Adams Brooks
Room for Cho? false
- Thêm: đặt tên mới vào chỉ số
size(dòng trống đầu tiên), rồi cộng 1 vàosize. Hãy kiểm tra trước là còn dòng trống. - Tìm: đi qua các chỉ số từ 0 đến
size - 1và trả về chỉ số của kết quả khớp đầu tiên, hoặc-1nếu không có. Đây là một tìm kiếm tuần tự (linear search). Các String được so sánh bằngequals, không phải==. - Xóa: tìm tên, trượt mọi tên phía sau lên một dòng để lấp khoảng trống, rồi trừ 1 khỏi
size. Bản sao cũ còn lại ở cuối giờ nằm trong vùng dự phòng, nên nó không còn được tính.
Vòng lặp xóa dừng ở size - 1 vì nó đọc names[i + 1]. Hãy thu nhỏ để kiểm tra: với một tên trong danh sách và remove được gọi trên nó, at là 0 và điều kiện vòng lặp 0 < 0 là sai, nên nó chạy không lần nào và size thành 0. Nếu viết là i < size, lượt cuối sẽ đọc một dòng vượt quá các tên đang dùng, và trên một tờ giấy kẹp đã đầy thì đó là names[6], sẽ ném ArrayIndexOutOfBoundsException.
Nếu thứ tự không quan trọng, có một cách xóa nhanh hơn: sao chép tên cuối vào chỗ trống và trừ 1 khỏi size. Một lần di chuyển thay vì nhiều lần. Bài hướng dẫn về ArrayList cho thấy một lớp làm giúp bạn toàn bộ việc ghi sổ này.
Đừng dán nó. Hãy thêm vào chương trình một phương thức insertAt(int index, String name) đặt một suất đặt chỗ đến muộn vào một dòng cho trước và dời mọi người bên dưới xuống một dòng. Tự gõ ra là cách để hướng của vòng lặp ghi nhớ được. Một dòng hợp lệ là từ 0 đến size; từ chối mọi giá trị khác. Hãy thử với Ortiz, Patel và Nguyen trong danh sách: chèn Kim vào dòng 0, rồi Lee vào dòng 2.
Xem đáp án
Hãy trượt từ phía sau, nếu không mỗi lần di chuyển sẽ ghi đè lên tên bạn cần ở bước kế tiếp:
static boolean insertAt(int index, String name) {
if (size == names.length || index < 0 || index > size) {
return false;
}
for (int i = size; i > index; i--) {
names[i] = names[i - 1]; // move from the back first
}
names[index] = name;
size++;
return true;
}size 4: Kim Ortiz Patel Nguyen
size 5: Kim Ortiz Lee Patel NguyenĐiều mới trong bài hướng dẫn này#
- Kiểu dữ liệu
int[]: kiểu bạn đã biết, cộng thêm dấu ngoặc vuông. new int[6]để dành chỗ cho 6 phần tử, tất cả được đặt về một giá trị mặc định.party[i]để đọc hoặc ghi một phần tử, với chỉ số từ 0 đếnlength - 1.length, một trường không có dấu ngoặc đơn, và các vòng lặp dùng nó: for-each cho giá trị,forđếm cho vị trí.- Mảng là tham chiếu, nên sao chép hoặc truyền biến sẽ chia sẻ mảng; một phương thức cũng có thể dựng một mảng mới và
returnnó. - Danh sách khởi tạo như
{4, 2, 5, 3}, cùngArrays.toString,Arrays.copyOfvàArrays.equals. String[] argslà một mảng String bình thường.- Mảng vừa đủ so với mảng lớn hơn mức cần dùng, và cách thêm, tìm, xóa trong mảng lớn hơn mức cần dùng.
Mảng là một hàng cố định các phần tử được đánh số từ 0 đến length - 1, và biến giữ một mũi tên trỏ tới nó, không phải chính các phần tử. Sao chép hoặc truyền biến sẽ chia sẻ các phần tử; mảng lớn hơn mức cần dùng cần biến đếm size riêng, và mọi vòng lặp dừng ở đó.
Những chỗ dễ sai#
party.length()có dấu ngoặc đơn. Với mảng làlength, một trường. Chuỗi dùnglength().- Lặp với
i <= party.length. Chỉ số hợp lệ cuối cùng làlength - 1; cách này némArrayIndexOutOfBoundsException. - Chia hai int để lấy trung bình.
14 / 4là 3. Hãy ép một vế sangdoubletrước. - Nghĩ rằng
int[] b = a;sao chép mảng. Nó sao chép tham chiếu. Hãy dùngArrays.copyOfhoặc một vòng lặp. - So sánh mảng bằng
==hoặc in chúng trực tiếp. Hãy dùngArrays.equalsvàArrays.toString. - Thay đổi phần tử qua biến for-each. Nó là một bản sao của giá trị. Hãy dùng vòng lặp đếm để thay đổi phần tử.
- Lặp mảng lớn hơn mức cần dùng đến
length. Hãy dừng ởsize; phần còn lại là dự phòng, thường lànull, và gọiequalstrênnullsẽ némNullPointerException. - Quên
size++hoặcsize--. Dữ liệu trông đúng còn số đếm thì sai, nên lần thêm hay vòng lặp kế tiếp sẽ hoạt động sai. - Dùng
{4, 2, 5, 3}sau dòng khai báo. Hãy viếtparty = new int[] {4, 2, 5, 3};thay vào đó. - Coi
args[0]là một số. Nó là một String. Hãy chuyển nó bằngInteger.parseInt, và kiểm traargs.lengthtrước.
Trong bài thi: nếu câu hỏi nói “viết một phương thức”, chỉ viết phương thức: phần khai báo, phần thân và return. Nếu nói “viết một chương trình”, hãy có đủ lớp và main. Đọc câu hỏi, đọc lại lần nữa, trả lời, rồi đọc thêm một lần để 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ã đó.
- Sau
double[] p = new double[3];vàString[] s = new String[2];, mỗi mảng chứa gì? - Hãy viết một phương thức
countAbove(int[] nums, int limit)trả về số phần tử lớn hơnlimit. - Chương trình in ra gì?
int[] x = {4, 5, 6}; int[] y = x; y[2] = 0; x = new int[] {7, 8}; System.out.println(Arrays.toString(x)); System.out.println(Arrays.toString(y)); - Hãy viết một phương thức nhận một
int[]và trả về một mảng mới với các phần tử theo thứ tự ngược, giữ nguyên mảng gốc. - Một mảng lớn hơn mức cần dùng
namescó độ dài 10 vàsizelà 4. Các chỉ số hợp lệ của những mục đang dùng là gì, và hai dòng nào thêm"Zoe"? - Trong một mảng lớn hơn mức cần dùng chứa
[A, B, C, D]vớisizebằng 4, hãy liệt kê các bước di chuyển mà phép xóa giữ thứ tự thực hiện để xóaB, và cho biếtsizemới.
Lời giải#
pchứa[0.0, 0.0, 0.0]vàschứa[null, null].newđiền số bằng không, boolean bằngfalse, và các kiểu đối tượng bằngnull.- Vòng lặp for-each là đủ, vì chỉ cần các giá trị:
public class QSum { public static int countAbove(int[] nums, int limit) { int count = 0; for (int n : nums) { if (n > limit) { count++; } } return count; } public static void main(String[] args) { int[] temps = {71, 88, 93, 64, 90}; System.out.println(countAbove(temps, 85)); } }3 y = xchia sẻ mảng đầu tiên, nêny[2] = 0thay đổi nó. Sau đóxđược cho trỏ tới một mảng mới, cònyvẫn trỏ tới mảng cũ:import java.util.Arrays; public class QTrace { public static void main(String[] args) { int[] x = {4, 5, 6}; int[] y = x; y[2] = 0; x = new int[] {7, 8}; System.out.println(Arrays.toString(x)); System.out.println(Arrays.toString(y)); } }[7, 8] [4, 5, 0]- Tạo một mảng mới cùng độ dài và điền nó từ phía sau của mảng gốc:
import java.util.Arrays; public class QReverse { public static int[] reversed(int[] a) { int[] r = new int[a.length]; for (int i = 0; i < a.length; i++) { r[i] = a[a.length - 1 - i]; } return r; } public static void main(String[] args) { int[] a = {1, 2, 3, 4}; System.out.println(Arrays.toString(reversed(a))); System.out.println(Arrays.toString(a)); } }[4, 3, 2, 1] [1, 2, 3, 4] - Chỉ số từ 0 đến 3. Để thêm:
names[size] = "Zoe";rồisize++;, sau khi đã kiểm tra trước rằngsize < names.length. Bở chỉ số 1. Trượt sang trái: chỉ số 1 nhậnC, chỉ số 2 nhậnD. Rồisizethành 3, nên các mục đang dùng là[A, C, D].Dcũ vẫn nằm ở chỉ số 3 giờ ở trong vùng dự phòng và bị bỏ qua.
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ể khai báo một mảng, tạo chỗ chứa cho nó bằng
new, và khởi tạo giá trị, kể cả bằng danh sách khởi tạo. - ☐ Tôi có thể truyền một mảng cho phương thức và trả về một mảng từ phương thức, và dự đoán điều bên gọi thấy.
- ☐ Tôi có thể giải thích mảng vừa đủ và mảng lớn hơn mức cần dùng, và vì sao mảng được lưu dưới dạng tham chiếu.
- ☐ Tôi có thể duyệt qua mọi phần tử bằng vòng lặp đếm và vòng lặp for-each.
- ☐ Tôi có thể tìm một phần tử, xóa một phần tử và thêm một phần tử trong mảng lớn hơn mức cần dùng.
Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí
40 câu luyện tập về khai báo, truyền và mảng lớn hơn mức cần dùng, với 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 ngoại tuyến, không cần tài khoản.
Luyện tập mảng →Câu hỏi thường gặp#
Làm thế nào để khai báo và tạo một mảng trong Java?
Khai báo biến với dấu ngoặc vuông sau kiểu, chẳng hạn int[] scores;. Tạo chỗ chứa bằng new và một kích thước, chẳng hạn scores = new int[5];. Hoặc làm cả hai và điền giá trị cùng lúc bằng một danh sách khởi tạo: int[] scores = {90, 85, 77};.
Giá trị mặc định trong một mảng Java mới tạo là gì?
Các phần tử số bắt đầu bằng 0 (hoặc 0.0), phần tử boolean bằng false, phần tử char bằng ký tự null, và phần tử của bất kỳ kiểu đối tượng nào, kể cả String, bằng null.
Với mảng là length hay length()?
length, không có dấu ngoặc đơn. Nó là một trường của mọi mảng. Chuỗi dùng phương thức length() có dấu ngoặc đơn, còn ArrayList dùng size().
Điều gì gây ra ArrayIndexOutOfBoundsException?
Dùng một chỉ số nhỏ hơn 0 hoặc bằng hay lớn hơn độ dài của mảng. Các chỉ số hợp lệ chạy từ 0 đến length - 1. Nguyên nhân thường gặp là điều kiện vòng lặp viết là i <= array.length thay vì i < array.length.
Tại sao thay đổi một mảng bên trong phương thức lại làm nó thay đổi đối với bên gọi?
Vì biến mảng giữ một tham chiếu đến mảng. Phương thức nhận một bản sao của tham chiếu đó, cùng trỏ tới một mảng, nên các thay đổi ở phần tử đều được bên gọi thấy. Tuy nhiên, cho tham số trỏ sang một mảng hoàn toàn mới thì không ảnh hưởng đến biến của bên gọi.
Mảng lớn hơn mức cần dùng (oversized array) là gì?
Là mảng được tạo lớn hơn số phần tử đang lưu, đi kèm một biến int riêng đếm số phần tử đang dùng. Các phần tử được giữ ở chỉ số từ 0 đến size - 1, nên có thể thêm và xóa phần tử mà không cần tạo mảng mới, cho đến khi mảng đầy.
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.