Tổng quan về collection trong Java — vì sao cần collection

1. Giới thiệu

Trước đây chúng ta đã từng bàn về “mảng vô hạn” — tức danh sách. Hãy đào sâu kiến thức hơn nữa, và để làm vậy, một lần nữa tự hỏi: thế nào là mảng “cổ điển”? Nếu nhìn kỹ, nó giống như một hộp dụng cụ với số ngăn cố định. Giả sử hộp có 10 ngăn. Bạn có thêm dụng cụ thứ 11, thì sao? Phải mua hộp mới! Mảng truyền thống cũng vậy: kích thước cố định và sau khi tạo, độ dài của nó sẽ không thay đổi.

Nếu cần thêm hoặc xóa phần tử, bạn phải tạo mảng mới và sao chép dữ liệu thủ công. Trong mảng, bạn có thể tìm phần tử theo chỉ mục một cách dễ dàng và nhanh chóng, nhưng chèn phần tử vào giữa mảng không chỉ là “chèn” mà là “dịch tất cả sang phải”, còn khi xóa là “dịch tất cả sang trái”. Việc này chậm và bất tiện. Ngoài ra, mảng không chứa “logic” bổ sung nào: nó chỉ giữ một tập hợp ô, còn việc sắp xếp, tìm theo nội dung hay kiểm tra tính duy nhất phải làm bằng công cụ bên ngoài.

Ví dụ: danh sách sinh viên động

Giả sử bạn viết ứng dụng quản lý sinh viên trong một nhóm. Ban đầu nhóm có 5 người, sau đó thêm một người, rồi có người rời đi. Với mảng, nó sẽ trông như thế này:

String[] students = new String[5];
students[0] = "Ivan";
students[1] = "Mariya";
// v.v...

// Ôi, có thêm một sinh viên nữa
// Cần tạo một mảng mới!
String[] newStudents = new String[6];
for (int i = 0; i < students.length; i++) {
    newStudents[i] = students[i];
}
newStudents[5] = "Aleksey";
students = newStudents;

Tiện không? Nói nhẹ thì là không. Nếu có nhiều thao tác như vậy thì sao? Lúc này bạn sẽ muốn thứ gì đó tiện hơn...

2. Collection là gì?

Collection là một đối tượng phục vụ như một container để lưu trữ một nhóm đối tượng khác (các phần tử). Collection cho phép thêm, xóa, duyệt phần tử, cũng như thực hiện các thao tác khác: tìm kiếm, sắp xếp, lọc, v.v.

Trong Java, mọi collection đều hiện thực hoặc kế thừa từ interface Collection (còn với ánh xạ — từ Map). Collection không chỉ là “một đống thứ” mà là một cấu trúc cung cấp tập phương thức tiện lợi, được thiết kế kỹ để làm việc với phần tử.

Vì sao collection là đối tượng?

Bởi vì collection được hiện thực dưới dạng các lớp, nghĩa là bạn có thể tạo collection của mọi loại đối tượng, kết hợp chúng, kế thừa, mở rộng, dùng trong các lớp và phương thức của bạn.

Ví dụ:

import java.util.ArrayList;
import java.util.List;

List<String> students = new ArrayList<>();
students.add("Ivan");
students.add("Mariya");
students.add("Aleksey");

Vậy là xong! Giờ bạn có thể thêm bao nhiêu sinh viên tùy ý mà không phải bận tâm đến kích thước mảng.

3. Những bài toán điển hình mà collection giải quyết

Collection là con dao đa năng để làm việc với dữ liệu. Chúng giúp bạn giải quyết các bài toán sau:

• Lưu danh sách dữ liệu động: Ví dụ danh sách sinh viên, công việc trong bộ lập lịch, tin nhắn trong chat.
• Tìm kiếm và lọc: Nhanh chóng tìm phần tử, kiểm tra sự tồn tại, lấy tất cả phần tử thỏa điều kiện nào đó.
• Sắp xếp: Dễ dàng sắp xếp phần tử theo tiêu chí mong muốn.
• Xóa và thêm phần tử: Chèn và xóa phần tử ở bất kỳ vị trí nào trong collection mà không cần tự sao chép mảng.
• Nhóm theo khóa: Ví dụ danh bạ điện thoại, nơi mỗi tên tương ứng với một số điện thoại.
• Bảo đảm tính duy nhất: Ví dụ tập hợp tất cả từ duy nhất trong văn bản.

Ví dụ: danh bạ điện thoại

Với mảng:

• Làm sao tìm số theo tên? Phải duyệt mảng và so sánh tên.
• Làm sao thêm một cặp mới? Phải mở rộng mảng.
• Làm sao bảo đảm tên không trùng? Càng khó hơn.

Với collection:

• Dùng Map<String, String> — và mọi thứ hoạt động “ngay từ hộp”.

4. Tổng quan các loại collection chính

Trong Java, collection được chia thành ba nhóm chính:

Danh sách (List)

• Collection có thứ tự, cho phép trùng lặp.
• Có thể lấy phần tử theo chỉ mục.
• Ví dụ: ArrayList, LinkedList.

Tập hợp (Set)

• Chỉ chứa phần tử duy nhất.
• Không có truy cập theo chỉ mục.
• Ví dụ: HashSet, TreeSet.

Ánh xạ (Map)

• Lưu các cặp key–value.
• Tìm nhanh theo key.
• Ví dụ: HashMap, TreeMap.

Sơ đồ trực quan (rất ước lệ):

+------------------+       +-------------------+      +---------------------+
|     List         |       |        Set        |      |         Map         |
|------------------|       |-------------------|      |---------------------|
| [a, b, c, d, a]  |       | {a, b, c, d}      |      | {a=1, b=2, c=3}     |
| Chỉ mục: có      |       | Chỉ mục: không    |      | Tìm theo khóa       |
| Trùng lặp: có    |       | Trùng lặp: không  |      | Khóa là duy nhất    |
+------------------+       +-------------------+      +---------------------+

5. Những lưu ý hữu ích

Khi nào dùng collection nào?

List — khi thứ tự phần tử quan trọng, cần cho phép trùng lặp, cần truy cập theo chỉ mục (ví dụ danh sách công việc, lịch sử tin nhắn).

Set — khi chỉ cần các phần tử duy nhất, không quan tâm thứ tự (ví dụ tập người dùng duy nhất).

Map — khi cần ánh xạ key với value (ví dụ danh bạ, nơi tên là key và số điện thoại là value).

Liên hệ đời sống

List — hàng chờ ở căng-tin: ai đến trước phục vụ trước, có thể đứng vào hàng nhiều lần (trùng lặp).

Set — danh sách khách mời: mỗi khách chỉ có một lần (duy nhất).

Map — sổ địa chỉ: mỗi tên có một số điện thoại tương ứng.

Ghi nhớ nhanh: collection vs mảng

6. Liên hệ giữa collection và OOP

Collection là các đối tượng hiện thực những interface nhất định (List, Set, Map). Điều đó có nghĩa là bạn có thể:

• Lưu trong collection bất kỳ đối tượng nào, kể cả các thực thể từ lớp do bạn định nghĩa.
• Tạo collection của collection (ví dụ, list các list).
• Dùng collection làm tham số và giá trị trả về của phương thức.
• Mở rộng chức năng của collection thông qua kế thừa và kết hợp (composition).

Ví dụ: collection các đối tượng thuộc lớp của bạn

import java.util.ArrayList;
import java.util.List;

class Student {
    String name;
    int age;
    // Hàm khởi tạo, getter/setter, v.v.
}

public class Main {
    public static void main(String[] args) {
        List<Student> group = new ArrayList<>();
        group.add(new Student("Ivan", 20));
        group.add(new Student("Mariya", 21));
        // v.v.
    }
}

7. Lỗi thường gặp khi làm việc với collection

Lỗi №1: Dùng collection không có kiểu (raw types).
Nếu bạn viết ArrayList list = new ArrayList(), thì khi thêm bất kỳ đối tượng nào (ví dụ trộn cả chuỗi và số) trình biên dịch sẽ không cảnh báo, nhưng khi cố lấy phần tử ra và ép về kiểu cần thiết, bạn có thể gặp lỗi runtime (ClassCastException). Luôn dùng generics: ArrayList<String> list = new ArrayList<>().

Lỗi №2: Quên import lớp cần thiết.
Nếu bạn thấy lỗi “cannot find symbol”, hãy kiểm tra rằng ở đầu tệp có dòng import java.util.ArrayList; hoặc import phù hợp cho collection bạn dùng.

Lỗi №3: Nhầm lẫn giữa collection và mảng.
Collection không phải mảng! Collection không có trường length, thay vào đó hãy dùng phương thức size(). Mảng không có phương thức add(), còn collection không có toán tử [] để truy cập theo chỉ mục (chỉ với list mới truy cập qua get(index)).

Lỗi №4: Kỳ vọng rằng thứ tự phần tử luôn được giữ nguyên.
Nếu bạn dùng Set hoặc Map, thứ tự phần tử không được đảm bảo (trừ khi bạn dùng các hiện thực đặc thù như LinkedHashSet hoặc TreeMap). Với dữ liệu cần có thứ tự, hãy dùng List hoặc các collection phù hợp.

Lỗi №5: Dùng kiểu nguyên thủy trong collection.
Collection chỉ có thể chứa đối tượng, không phải primitive. Tức là không thể tạo List<int>, chỉ List<Integer>. Đừng quên các lớp bao (wrapper class)!