Một danh sách bài hát cứ thay đổi liên tục#
Hãy hình dung tờ giấy dán trên sàn sân khấu ở một buổi diễn nhỏ: danh sách bài hát của ban nhạc. Trước buổi diễn, nó được viết lại hết lần này đến lần khác. Một bài được thêm vào cuối, một bài mới được nhét lên đầu, một bài chậm bị cắt, hai bài đổi chỗ cho nhau. Chưa có ban nhạc nào từng chơi đúng danh sách đã viết ở buổi tập đầu tiên.
Bài hướng dẫn về mảng kết thúc bằng một mẫu dành riêng cho tình huống này: mảng lớn hơn mức cần dùng kèm một số đếm. Bạn tự viết phần thêm, tìm và xóa:
String[] songs = new String[6]; // the sheet: 6 lines
int count = 0; // how many lines are in use
songs[count] = "Gravel Road"; count++; // add at the first empty line
Bạn chọn kích thước và tự cập nhật count bằng tay. Bài hát thứ bảy sẽ không còn chỗ.
ArrayList chính là cặp đó, mảng và số đếm, được gói vào một đối tượng với các phương thức đã viết sẵn. Đó là phần mới duy nhất. Bên dưới nó vẫn là một mảng lớn hơn mức cần dùng bình thường, được giấu đi. Bài hướng dẫn này xây dựng một chương trình, SetList, xoay quanh tờ danh sách đó, và cho thấy đầu ra thật ở mỗi bước.
import java.util.ArrayList;
public class SetList {
public static void main(String[] args) {
ArrayList<String> songs = new ArrayList<>(); // the array and its count, in one object
songs.add("Gravel Road");
songs.add("Static Bloom");
songs.add("Northbound");
System.out.println(songs + " size " + songs.size());
}
}
[Gravel Road, Static Bloom, Northbound] size 3
Từng ký hiệu, gọi tên rõ:
import java.util.ArrayList;:ArrayListnằm trong góijava.util.ArrayList<String>: kiểu nằm trong dấu ngoặc nhọn,<và>, cho biết danh sách chứa gì. Nó được gọi là đối số kiểu, một phần của generic, sẽ có bài hướng dẫn riêng ngay sau đây.new ArrayList<>(): tạo một danh sách rỗng. Cặp ngoặc nhọn rỗng, gọi là toán tử kim cương (diamond), bảo Java sao chép kiểu từ vế trái.songs.add(x)đặtxvào cuối.songs.size()trả về số phần tử trong danh sách: nó chính là biếncount, được giữ giúp bạn.
Giống như mảng, danh sách đếm từ 0, nên phần tử cuối cùng nằm ở chỉ số size() - 1.
ArrayList làm được gì mà mảng không làm được#
So sánh song song:
| Mảng | ArrayList | |
|---|---|---|
| Kích thước | cố định khi tạo | lớn lên và thu nhỏ khi cần |
| Có bao nhiêu phần tử | arr.length (hoặc biến đếm của bạn) | list.size() |
| Đọc hoặc ghi một phần tử | arr[i], arr[i] = x | list.get(i), list.set(i, x) |
| Thêm vào cuối | mã và biến đếm của bạn | list.add(x) |
| Chèn hoặc xóa ở giữa | vòng lặp dịch chuyển do bạn tự viết | list.add(i, x), list.remove(i) |
| Tìm kiếm | vòng lặp của bạn | list.contains(x), list.indexOf(x) |
| Chứa được kiểu nguyên thủy? | có: int[] | không: dùng lớp bao, ArrayList<Integer> |
| In ra | cần Arrays.toString | println(list) dùng được |
Mảng vẫn thắng ở hai điểm: chúng chứa trực tiếp các giá trị nguyên thủy như int, và chúng nhanh hơn và nhẹ hơn một chút. Khi số lượng cố định, dùng mảng là đủ. Khi phần tử đến rồi đi, hãy dùng ArrayList.
Danh sách của Python tự lớn lên; Java đưa cho bạn cả mảng cố định lẫn danh sách tự lớn, và mong bạn chọn một.
Thêm, đọc, tìm và xóa#
Mỗi thao tác trên mảng đều có một phương thức của ArrayList, và các chú thích cho biết mỗi lời gọi làm gì. Có hai cái cần nhìn kỹ hơn: add(i, x) chèn và đẩy mọi phần tử phía sau sang phải một vị trí, còn set(i, x) thay thế mà không đẩy gì cả.
Gravel Road, Static Bloom, Northbound và Last Ferry được thêm vào, rồi add(1, "Paper Moonlight") chạy. Bây giờ bài nào ở chỉ số 3? Đó là bài mà set(3, "Slow Burn") sẽ thay thế.
Xem đáp án
Northbound. Nó vốn ở chỉ số 2, và lệnh chèn ở chỉ số 1 đã đẩy nó sang phải một vị trí, đến chỉ số 3. Vì vậy set(3, ...) thay Northbound ra.
import java.util.ArrayList;
public class SetList {
public static void main(String[] args) {
ArrayList<String> songs = new ArrayList<>();
songs.add("Gravel Road"); // add at the end
songs.add("Static Bloom");
songs.add("Northbound");
songs.add("Last Ferry");
songs.add(1, "Paper Moonlight"); // insert at index 1; later songs slide right
System.out.println(songs);
System.out.println("Opener: " + songs.get(0)); // read one item
String old = songs.set(3, "Slow Burn"); // replace one item; returns the old one
System.out.println("Swapped out " + old + ": " + songs);
System.out.println(songs.contains("Slow Burn")); // true or false
System.out.println(songs.indexOf("Static Bloom")); // first index that matches
System.out.println(songs.indexOf("Northbound")); // -1 means not found
boolean cut = songs.remove("Static Bloom"); // by value: returns true or false
String dropped = songs.remove(0); // by index: returns the item removed
System.out.println(cut + ", dropped " + dropped + ": " + songs);
}
}
[Gravel Road, Paper Moonlight, Static Bloom, Northbound, Last Ferry]
Opener: Gravel Road
Swapped out Northbound: [Gravel Road, Paper Moonlight, Static Bloom, Slow Burn, Last Ferry]
true
2
-1
true, dropped Gravel Road: [Paper Moonlight, Slow Burn, Last Ferry]
Cả hai kiểu remove đều lấp khoảng trống, và kích thước giảm 1. remove("Static Bloom") trả về true (trả về false nếu không có gì khớp). remove(0) trả về bài hát mà nó vừa lấy ra.
contains, indexOf và remove(x) đều so sánh các phần tử bằng equals, không phải ==. Đó là lý do lời khuyên về việc ghi đè equals(Object) trong bài hướng dẫn về Object quan trọng với các lớp của bạn.
get(i) và set(i, x) cần một chỉ số từ 0 đến size() - 1. add(i, x) cho phép thêm một giá trị nữa: i có thể bằng size(), nghĩa là “ở cuối”. Bất kỳ giá trị nào khác vẫn biên dịch được, rồi ném ra IndexOutOfBoundsException.
Số, vòng lặp và phương thức#
Kỹ sư âm thanh giữ một con số cho mỗi bài hát, theo thứ tự biểu diễn: bài đó chạy bao nhiêu phút. Lần thử đầu tiên hiển nhiên là ArrayList<int>. Đây là điều trình biên dịch nói, được cho xem có chủ ý để bạn nhận ra nó:
import java.util.ArrayList;
public class SetList {
public static void main(String[] args) {
ArrayList<int> minutes = new ArrayList<>();
}
}
SetList.java:5: error: unexpected type
ArrayList<int> minutes = new ArrayList<>();
^
required: reference
found: int
1 error
“Required: reference, found: int” nghĩa là đối số kiểu phải là kiểu tham chiếu (một lớp), không phải kiểu nguyên thủy như int hay double. Đó là lý do lớp bao tồn tại: Integer bọc một int trong một đối tượng, và Double, Boolean và Character làm điều tương tự cho kiểu của chúng. Vì vậy danh sách là ArrayList<Integer>.
Bạn vẫn viết số bình thường. Java biến một int thành Integer khi đưa vào, việc này gọi là đóng hộp tự động (autoboxing). Nó biến Integer trở lại thành int khi lấy ra, việc này gọi là mở hộp (unboxing). Phần lớn thời gian bạn sẽ không nhận ra. Cái bẫy remove ở phần sau là chỗ bạn sẽ nhận ra.
Cả hai vòng lặp trong bài hướng dẫn về mảng đều dùng được với danh sách, với size() thay cho length và get(i) thay cho [i]. Một phương thức nhận một danh sách sẽ nhận một bản sao của tham chiếu, mũi tên trỏ tới một danh sách duy nhất, giống như với mảng. Giờ chương trình điền danh sách chỉ trong một dòng. List.of (từ java.util.List) tạo một danh sách không thể thay đổi (không có add, set hay remove). Hàm tạo của ArrayList sao chép nó vào một danh sách bạn có thể thay đổi.
Các bài hát chạy 4, 3, 6, 5 và 3 phút. Hãy tính tổng thời lượng buổi diễn và độ dài trung bình của một bài trước khi đọc đầu ra.
Xem đáp án
Tổng là 21 phút và trung bình là 21 / 5 = 4,2 phút.
import java.util.ArrayList;
import java.util.List;
public class SetList {
public static int total(ArrayList<Integer> values) {
int sum = 0; // the accumulator starts at 0
for (int v : values) { // each Integer is unboxed to an int
sum += v;
}
return sum;
}
public static void main(String[] args) {
ArrayList<Integer> minutes = new ArrayList<>(List.of(4, 3, 6, 5, 3));
int sum = total(minutes);
System.out.println("Set length: " + sum + " min");
System.out.println("Average song: " + sum / minutes.size() + " min");
int longest = 0; // index of the longest song so far
for (int i = 1; i < minutes.size(); i++) {
if (minutes.get(i) > minutes.get(longest)) {
longest = i;
}
}
System.out.println("Longest: " + minutes.get(longest) + " min, at index " + longest);
}
}
Set length: 21 min
Average song: 4 min
Longest: 6 min, at index 2
Tổng đúng. total dùng mẫu bộ cộng dồn (accumulator): sum bắt đầu bằng 0 trước vòng lặp, tăng thêm một giá trị mỗi lượt, và được đọc sau khi vòng lặp kết thúc. Phần tìm bài dài nhất là mẫu trong bài hướng dẫn về mảng, dùng get(i) thay cho [i]. Nó giả định chỉ số 0 là bài dài nhất và để vòng lặp chứng minh điều ngược lại từ chỉ số 1.
Bây giờ là trung bình. 4 có hợp lý không? Bạn đã dự đoán 4,2. Vì 4 nằm giữa bài ngắn nhất (3) và bài dài nhất (6), nó trông có vẻ khả dĩ, và đó là cách lỗi này lọt qua. Hãy kiểm tra tương tự 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 hỏi mỗi vế có kiểu gì. sum là một int và minutes.size() trả về một int, nên 21 / 5 là phép chia số nguyên và bỏ mất .2. Hãy ép kiểu (chuyển đổi) một vế sang double trước: (double) sum / minutes.size().
Với phép ép kiểu đó, dòng ở giữa in ra Average song: 4.2 min. Không có gì trong total liên quan đến âm nhạc, nên nó cộng được mọi danh sách các Integer, đó là lý do tham số của nó tên là values.
Đừng dán đoạn này. Hãy viết một phương thức longSongs(ArrayList<Integer> values, int min) trả về một danh sách mới gồm mọi giá trị ít nhất bằng min, và giữ nguyên values. Trong bài hướng dẫn về mảng, trả về một mảng đã lọc cần 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. Danh sách cần bao nhiêu lượt duyệt? Hãy thử với danh sách của kỹ sư và min bằng 5, rồi in cả hai danh sách.
Xem đáp án
Một lượt duyệt, vì danh sách kết quả tự lớn lên khi bạn thêm vào:
public static ArrayList<Integer> longSongs(ArrayList<Integer> values, int min) {
ArrayList<Integer> result = new ArrayList<>();
for (int v : values) {
if (v >= min) {
result.add(v); // no counting pass: the list grows
}
}
return result;
}[6, 5]
[4, 3, 6, 5, 3]Nó chỉ đọc values, nên danh sách gốc không đổi.
Cái bẫy remove(int) so với remove(Object)#
Buổi diễn đang kéo dài quá, nên kỹ sư muốn cắt bài hát 3 phút. Lời gọi hiển nhiên là minutes.remove(3).
remove bị nạp chồng: có hai phương thức cùng tên và khác kiểu tham số. remove(int index) xóa theo vị trí. remove(Object o) xóa theo giá trị. Java chọn phương thức khớp chính xác nhất với những gì bạn truyền, và 3 là một int.
Danh sách là 4, 3, 6, 5, 3. Còn lại gì sau minutes.remove(3)?
Xem đáp án
4, 3, 6, 3. int 3 được hiểu là chỉ số 3, và phần tử ở chỉ số 3 là số 5. Không có bài 3 phút nào bị xóa, và không có lỗi nào xuất hiện.
import java.util.ArrayList;
import java.util.List;
public class SetList {
public static void main(String[] args) {
ArrayList<Integer> minutes = new ArrayList<>(List.of(4, 3, 6, 5, 3));
minutes.remove(3); // meant: cut the 3-minute song
System.out.println(minutes);
minutes = new ArrayList<>(List.of(4, 3, 6, 5, 3));
minutes.remove(Integer.valueOf(3)); // the value 3, as an object
System.out.println(minutes);
}
}
[4, 3, 6, 3]
[4, 6, 5, 3]
Dòng đầu cho thấy cái bẫy: số 5 biến mất, và không có gì cảnh báo bạn. Để xóa theo giá trị, hãy đưa cho remove một đối tượng thay vì một int. Integer.valueOf(3) tạo một Integer chứa 3, nên Java chọn remove(Object). Nó chỉ xóa số 3 đầu tiên, số ở chỉ số 1, và để lại số thứ hai.
Ở đây đóng hộp tự động không can thiệp: Java trước tiên tìm phương thức khớp mà không cần đóng hộp, và remove(int) khớp.
Xóa trong khi lặp#
Khung giờ vừa ngắn đi, nên quy tắc mới là: cắt mọi bài dài hơn 4 phút. Danh sách bây giờ là 4, 6, 5, 3.
Cả hai phương thức dưới đây đều thay đổi danh sách của bên gọi thông qua bản sao mũi tên của chúng. Ở đây values.remove(i) truyền một int có chủ ý, vì lần này ta muốn nói đến chỉ số.
Những bài nào nên còn lại? Sau đó hãy dò từng bước vòng lặp xuôi bằng tay: thực tế nó để lại gì?
Xem đáp án
Nó nên để lại 4 và 3. Vòng lặp xuôi xóa số 6 ở chỉ số 1, và số 5 trượt vào chỉ số 1. Sau đó i++ chuyển sang chỉ số 2 mà không bao giờ kiểm tra số 5, nên nó để lại 4, 5, 3.
import java.util.ArrayList;
import java.util.List;
public class SetList {
public static void cutForward(ArrayList<Integer> values, int max) {
for (int i = 0; i < values.size(); i++) {
if (values.get(i) > max) {
values.remove(i); // the next song slides into index i
}
}
}
public static void cutBackward(ArrayList<Integer> values, int max) {
for (int i = values.size() - 1; i >= 0; i--) {
if (values.get(i) > max) {
values.remove(i); // only checked songs slide
}
}
}
public static void main(String[] args) {
ArrayList<Integer> a = new ArrayList<>(List.of(4, 6, 5, 3));
cutForward(a, 4);
System.out.println("forward: " + a);
ArrayList<Integer> b = new ArrayList<>(List.of(4, 6, 5, 3));
cutBackward(b, 4);
System.out.println("backward: " + b);
ArrayList<Integer> c = new ArrayList<>(List.of(4, 6, 5, 3));
c.removeIf(m -> m > 4); // remove every m where m > 4
System.out.println("removeIf: " + c);
}
}
forward: [4, 5, 3]
backward: [4, 3]
removeIf: [4, 3]
Vòng lặp xuôi chỉ xóa một trong hai bài dài. Sau khi xóa, phần tử kế tiếp dịch vào chỉ số i, và i++ nhảy thẳng qua nó.
Thu nhỏ về trường hợp nhỏ nhất. Chỉ lấy hai bài dài, [6, 5]. Xuôi: ở i = 0 số 6 bị xóa, còn [5]. Rồi i thành 1, điều kiện 1 < 1 sai, và vòng lặp kết thúc khi số 5 vẫn còn đó. Ngược: i bắt đầu ở 1 và số 5 bị xóa; rồi i thành 0 và số 6 bị xóa. Danh sách rỗng, đúng như mong muốn.
Lặp ngược sửa được lỗi vì những phần tử duy nhất bị trượt là những phần tử vòng lặp đã kiểm tra rồi. removeIf làm trọn việc chỉ trong một lời gọi. Bạn đưa cho nó một lambda, một phương thức nhỏ không tên: m -> m > 4 đọc là “với m, cho biết m > 4 có đúng không”. Mọi phần tử trả lời true đều bị xóa.
Vòng lặp ngược bắt đầu ở chỉ số cuối, size() - 1, không phải ở size(). Nó chạy khi i >= 0, nên chỉ số 0 cũng được kiểm tra. Bắt đầu ở size() sẽ ném IndexOutOfBoundsException ngay ở lần get đầu tiên. Viết i > 0 sẽ lặng lẽ bỏ qua bài mở màn.
Còn việc xóa bên trong vòng lặp for-each thì sao? Đây là đầu ra kỳ lạ của nó, cố ý cho xem:
SetList.javaimport java.util.ArrayList;
import java.util.List;
public class SetList {
public static void main(String[] args) {
ArrayList<Integer> d = new ArrayList<>(List.of(4, 6, 5, 3));
for (int m : d) {
if (m > 4) {
d.remove(Integer.valueOf(m));
}
}
System.out.println("for-each: " + d);
}
}
Exception in thread "main" java.util.ConcurrentModificationException
at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1095)
at java.base/java.util.ArrayList$Itr.next(ArrayList.java:1049)
at SetList.main(SetList.java:7)
Vòng lặp for-each duyệt danh sách bằng một đối tượng giúp việc ẩn gọi là iterator, và iterator nhận ra có thay đổi nên ném ConcurrentModificationException. Việc kiểm tra này không được đảm bảo: chẳng hạn xóa phần tử áp chót thì vòng lặp chỉ kết thúc sớm và bỏ qua phần tử cuối. Đừng bao giờ gọi remove trên một danh sách bên trong vòng lặp for-each duyệt chính danh sách đó.
Kích thước so với dung lượng#
ArrayList là một mảng lớn hơn mức cần dùng cộng với một số đếm. Hai con số mô tả nó:
- Kích thước (size): số phần tử trong danh sách, do
size()trả về. Chỉ các chỉ số nhỏ hơn nó mới dùng được. - Dung lượng (capacity): độ dài của mảng ẩn: bao nhiêu phần tử vừa trước khi nó phải lớn lên. Nó không bao giờ nhỏ hơn kích thước.
Khi một lệnh add cần thêm chỗ, ArrayList tạo một mảng ẩn lớn hơn và sao chép mọi phần tử sang. Tài liệu hứa một vài điều và bỏ ngỏ những điều khác:
new ArrayList<>()bắt đầu với dung lượng mười.new ArrayList<>(20)bắt đầu với 20, giúp bớt sao chép khi bạn biết đại khái sẽ có bao nhiêu phần tử.- Nó lớn lên bao nhiêu thì không được nêu rõ; lời hứa duy nhất là việc thêm phần tử có chi phí thấp tính trung bình. (Hiện nay OpenJDK tăng thêm khoảng một nửa, nhưng đó không phải là quy tắc.) Không có phương thức nào báo dung lượng.
ensureCapacity(n)làm nó lớn lên trước vàtrimToSize()thu nó lại vừa khít, và cả hai đều không đổi kích thước.
Một danh sách được tạo bằng new ArrayList<>(20), và một bài hát được thêm vào. Bây giờ bạn có thể set chỉ số 1 không?
Xem đáp án
Không. Dung lượng là chỗ chứa, không phải phần tử. Kích thước là 1, nên chỉ chỉ số 0 dùng được.
import java.util.ArrayList;
public class SetList {
public static void main(String[] args) {
ArrayList<String> songs = new ArrayList<>(20); // room for 20, holds 0
System.out.println("size " + songs.size());
songs.add("Gravel Road");
System.out.println("size " + songs.size() + ", opener " + songs.get(0));
songs.set(1, "Static Bloom");
}
}
size 0
size 1, opener Gravel Road
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 1 out of bounds for length 1
at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:100)
at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:106)
at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:302)
at java.base/java.util.Objects.checkIndex(Objects.java:385)
at java.base/java.util.ArrayList.set(ArrayList.java:470)
at SetList.main(SetList.java:9)
Hãy đọc kỹ thông báo: “Index 1 out of bounds for length 1”. Độ dài mà nó kiểm tra là kích thước, 1, không phải dung lượng 20. Bạn phải add một phần tử trước khi có thể get hoặc set chỉ số của nó.
Vector, người anh em đời cũ#
Vector là một lớp cũ hơn xây dựng trên cùng ý tưởng, với các phương thức gần như giống nhau. Nó có thể báo dung lượng, nên là nơi để quan sát mảng ẩn lớn lên.
Quy tắc lớn lên của nó được ghi trong tài liệu. new Vector<>() bắt đầu với dung lượng 10 và mức tăng dung lượng là 0, nghĩa là “tăng gấp đôi khi đầy”. new Vector<>(4, 2) bắt đầu ở 4 và mỗi lần tăng thêm 2.
import java.util.Vector;
public class SetList {
public static void main(String[] args) {
Vector<String> songs = new Vector<>();
System.out.println("size " + songs.size() + ", capacity " + songs.capacity());
for (int i = 1; i <= 10; i++) {
songs.add("Song " + i);
}
System.out.println("size " + songs.size() + ", capacity " + songs.capacity());
songs.add("Song 11");
System.out.println("size " + songs.size() + ", capacity " + songs.capacity());
Vector<String> tight = new Vector<>(4, 2); // start at 4, grow by 2
for (int i = 1; i <= 5; i++) {
tight.add("Song " + i);
}
System.out.println("size " + tight.size() + ", capacity " + tight.capacity());
}
}
size 0, capacity 10
size 10, capacity 10
size 11, capacity 20
size 5, capacity 6
Bài hát thứ mười một làm dung lượng tăng gấp đôi lên 20. Bài hát thứ năm làm tight lớn từ 4 lên 6.
Luồng (thread) là một dòng công việc bên trong chương trình đang chạy, và một số chương trình chạy nhiều luồng cùng lúc. Những điểm khác nhau mà bài thi hay hỏi:
ArrayList | Vector | |
|---|---|---|
| An toàn khi nhiều luồng dùng cùng lúc | không | có: các phương thức của nó được đồng bộ hóa (synchronized), nên mỗi lúc chỉ một luồng được dùng danh sách |
| Tốc độ | nhanh hơn | chậm hơn, vì việc khóa đó |
| Mảng ẩn lớn lên như thế nào | tài liệu không nêu rõ | tăng gấp đôi, trừ khi bạn đặt mức tăng dung lượng |
| Có thể báo dung lượng | không | có: capacity() |
| Tuổi đời | Java 1.2, lựa chọn thông thường ngày nay | Java 1.0, được giữ lại chủ yếu cho mã cũ |
Đây là cùng một sự đánh đổi như StringBuilder so với StringBuffer trong bài hướng dẫn về Chuỗi. Bản được đồng bộ hóa thì an toàn khi dùng chung giữa các luồng, và trả giá bằng tốc độ. Với chương trình chạy một luồng như mọi chương trình trong bài hướng dẫn này, hãy dùng ArrayList.
Điều mới trong bài hướng dẫn này#
ArrayList<String>: một mảng lớn hơn mức cần dùng và số đếm của nó trong một đối tượng.add,add(i, x),get,setvàsize().contains,indexOfvà hai kiểuremove, đều dùngequals.ArrayList<Integer>, đóng hộp tự động và mở hộp.- Danh sách trong vòng lặp, làm tham số và làm giá trị trả về.
- Cái bẫy
remove(int)so vớiremove(Object). - Xóa trong vòng lặp: lặp ngược,
removeIf, không bao giờ dùng for-each. - Kích thước so với dung lượng.
Vector: đồng bộ hóa, tăng gấp đôi, cũ hơn.
ArrayList là một mảng lớn hơn mức cần dùng và tự giữ số đếm. size() là số phần tử bạn có; dung lượng là số phần tử vừa trước khi nó lặng lẽ lớn lên. Hãy dùng get, set, add và remove, và truyền Integer.valueOf(x) để xóa một số theo giá trị. Hãy xóa ngược trong vòng lặp, và nhớ rằng Vector là phiên bản cũ hơn, được đồng bộ hóa và tăng gấp đôi.
Những chỗ dễ sai#
ArrayList<int>. Đối số kiểu phải là lớp. Hãy viếtArrayList<Integer>.- Dùng
length,length()hoặc dấu ngoặc vuông với danh sách. Danh sách dùngsize()vàget(i). list.remove(3)trên danh sách Integer khi bạn muốn nói giá trị 3. Lệnh đó xóa chỉ số 3. Hãy dùngremove(Integer.valueOf(3)).- Xóa trong khi lặp xuôi. Phần tử kế tiếp trượt vào chỗ trống và bị bỏ qua. Hãy lặp ngược, hoặc dùng
removeIf. - Xóa bên trong vòng lặp for-each. Thường nó ném
ConcurrentModificationException, và khi không ném thì nó bỏ sót phần tử. - Nghĩ rằng
new ArrayList<>(20)cho bạn 20 phần tử. Nó cho dung lượng 20 và kích thước 0.get(0)sẽ lỗi cho đến khi bạnadd. - So sánh hai phần tử bằng
==. Hãy dùngequals.==so sánh các mũi tên, điều này có thể làm bạn bất ngờ với giá trịIntegernằm ngoài khoảng -128 đến 127.
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, import 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ã đó.
- Hãy nêu ba ưu điểm của
ArrayListso với mảng, và một ưu điểm của mảng. - Chương trình in ra gì?
ArrayList<String> q = new ArrayList<>(); q.add("A"); q.add("B"); q.add(0, "C"); q.add("D"); q.remove(1); q.set(1, "E"); System.out.println(q + " " + q.size()); - Một
ArrayList<Integer>chứa[1, 5, 9]. Danh sách là gì saulist.remove(1)? Cònlist.remove(Integer.valueOf(1))sẽ để lại gì? - Hãy viết một phương thức xóa mọi String ngắn hơn
minký tự khỏi mộtArrayList<String>. - Hãy giải thích sự khác nhau giữa kích thước và dung lượng. Sau
new ArrayList<>(50)và ba lần gọiadd, chúng là bao nhiêu? - Hãy nêu ba điểm khác nhau giữa
VectorvàArrayList.
Lời giải#
- ArrayList tự lớn lên và thu nhỏ; nó chèn và xóa ở giữa chỉ bằng một lời gọi, tự dịch chuyển giúp bạn; và nó có sẵn tìm kiếm (
contains,indexOf) và in ra. Mảng chứa trực tiếp kiểu nguyên thủy và nhanh hơn, nhẹ hơn một chút. - Từng bước: [A], [A, B], [C, A, B], [C, A, B, D], xóa chỉ số 1 được [C, B, D], rồi set chỉ số 1 được [C, E, D]:
import java.util.ArrayList; public class QTrace { public static void main(String[] args) { ArrayList<String> q = new ArrayList<>(); q.add("A"); q.add("B"); q.add(0, "C"); q.add("D"); q.remove(1); q.set(1, "E"); System.out.println(q + " " + q.size()); } }[C, E, D] 3 remove(1)truyền mộtint, nên nó xóa phần tử ở chỉ số 1, là số 5, còn lại[1, 9].remove(Integer.valueOf(1))truyền một đối tượng, nên nó xóa phần tử đầu tiên bằng 1, còn lại[5, 9].- Lặp ngược để việc xóa không bao giờ gây bỏ sót:
import java.util.ArrayList; public class QLong { public static void removeShort(ArrayList<String> words, int min) { for (int i = words.size() - 1; i >= 0; i--) { if (words.get(i).length() < min) { words.remove(i); } } } public static void main(String[] args) { ArrayList<String> w = new ArrayList<>(); w.add("a"); w.add("an"); w.add("apple"); w.add("ox"); w.add("banana"); removeShort(w, 3); System.out.println(w); } }[apple, banana] - Kích thước là số phần tử danh sách đang chứa; dung lượng là số phần tử mảng ẩn chứa được trước khi nó phải lớn lên. Ở đây kích thước là 3 và dung lượng là 50.
Vectorđược đồng bộ hóa (an toàn cho nhiều luồng) và vì vậy chậm hơn; nó tăng gấp đôi dung lượng khi lớn lên trừ khi bạn đặt mức tăng dung lượng, còn tài liệu không nóiArrayListtăng bao nhiêu;Vectorcó phương thứccapacity(); vàVectorlà lớp cũ hơn (Java 1.0) được giữ lại cho mã kế thừa, cònArrayListlà lựa chọn mặc định hiện đại.
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ể liệt kê các ưu điểm của ArrayList so với mảng.
- ☐ Tôi có thể giải thích mối quan hệ giữa kích thước và dung lượng.
- ☐ Tôi có thể áp dụng các thao tác trên mảng (khai báo, duyệt, tìm, thêm, xóa, truyền và trả về) cho ArrayList.
- ☐ Tôi có thể tránh cái bẫy
remove(int)và cái bẫy xóa trong vòng lặp xuôi. - ☐ Tôi có thể giải thích Vector là gì và những điểm khác nhau giữa Vector và ArrayList.
Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí
40 câu luyện tập về ArrayList, Vector và việc xóa trong khi lặp, 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.
Câu hỏi thường gặp#
Sự khác nhau giữa mảng và ArrayList trong Java là gì?
Mảng có độ dài cố định, được đặt khi tạo, và có thể chứa kiểu nguyên thủy. ArrayList tự lớn lên và thu nhỏ lại, có các phương thức như add, get, set, remove, contains và indexOf, và chỉ chứa đối tượng, nên kiểu nguyên thủy được lưu thông qua lớp bao như Integer.
Sự khác nhau giữa kích thước (size) và dung lượng (capacity) trong ArrayList là gì?
Kích thước là số phần tử trong danh sách, do size() trả về. Dung lượng là độ dài của mảng ẩn dùng để lưu các phần tử, và luôn ít nhất bằng kích thước. Khi một lệnh add vượt quá dung lượng, ArrayList tạo một mảng lớn hơn và sao chép các phần tử sang.
ArrayList lớn lên như thế nào?
ArrayList được tạo không có đối số bắt đầu với dung lượng là mười. Khi một lệnh add cần thêm chỗ, nó cấp phát một mảng lớn hơn và sao chép các phần tử sang. Tài liệu không nêu rõ lớn hơn bao nhiêu; hiện nay OpenJDK tăng thêm khoảng một nửa.
Tại sao remove(1) lại xóa nhầm phần tử trong ArrayList các Integer?
Vì remove được nạp chồng. Truyền một int sẽ gọi remove(int index), xóa theo vị trí. Để xóa theo giá trị, hãy truyền một đối tượng: list.remove(Integer.valueOf(1)).
Sự khác nhau giữa Vector và ArrayList là gì?
Các phương thức của Vector được đồng bộ hóa (synchronized), nên dùng chung giữa các luồng được an toàn nhưng chậm hơn. Vector tăng gấp đôi dung lượng khi lớn lên, trừ khi bạn đặt mức tăng dung lượng, còn tài liệu không nêu rõ ArrayList tăng bao nhiêu. Vector cũng có phương thức capacity(). Vector có từ Java 1.0 và được giữ lại chủ yếu cho mã cũ; ArrayList là lựa chọn thông thường.
Tại sao tôi không thể tạo ArrayList của int?
Đối số kiểu generic phải là lớp, không phải kiểu nguyên thủy. Hãy dùng lớp bao thay thế, ArrayList<Integer>. Java tự động chuyển đổi giữa int và Integer, việc này gọi là đóng hộp tự động (autoboxing) và mở hộp (unboxing).
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.