Hệ sinh thái dữ liệu động trong Java

Khi phát triển các ứng dụng phần mềm, việc lưu trữ nhóm dữ liệu là nhu cầu thường xuyên. Mặc dù mảng (Array) tồn tại từ lâu, nhưng chúng có hạn chế lớn về kích thước cố định, gây khó khăn khi không xác định được số lượng đối tượng cần xử lý lúc viết code. Để giải quyết vấn đề này, gói java.util cung cấp hệ thống lớp tập hợp (Collections Framework) linh hoạt với khả năng tự động mở rộng dung lượng.

Các cấu trúc này bao gồm List, Set, Queue và Map. Ngoài ra, việc sử dụng泛型 (Generics) khi khởi tạo giúp đảm bảo an toàn kiểu dữ liệu ngay từ giai đoạn biên dịch.

Phân loại cơ bản của Collections

Khung làm việc tập hợp được chia thành hai nhóm chính dựa trên cách tổ chức dữ liệu:

• Giao thức Collection: Quản lý một chuỗi các phần tử độc lập.
  • List: Duy trì thứ tự chèn vào và cho phép trùng lặp.
  • Set: Loại bỏ các phần tử giống nhau, chỉ chứa giá trị duy nhất.
  • Queue: Sắp xếp theo quy tắc hàng đợi để điều phối thứ tự xử lý.
• Giao thức Map: Tổ chức dữ liệu dưới dạng cặp "Chìa khóa - Giá trị" (Key-Value), cho phép tra cứu giá trị thông qua khóa.

Lưu ý rằng phương thức Arrays.asList() trả về một List nhưng nội bộ lại dùng mảng tĩnh, không thể thay đổi kích thước được nếu gọi thêm phần tử:

import java.util.List;
import java.util.Arrays;

public class StaticListExample {
    public static void main(String[] args) {
        // Khởi tạo danh sách cố định
        List<String> readOnlyItems = Arrays.asList("Item-A", "Item-B");
        
        // Dòng lệnh dưới đây sẽ gây lỗi thời chạy
        try {
            readOnlyItems.add("Item-C");
        } catch (UnsupportedOperationException e) {
            System.out.println("Không thể thêm phần tử vào danh sách cố định.");
        }
    }
}

Chi tiết về Danh sách (List)

List là nơi lưu trữ các phần tử có thứ tự và cho phép xuất hiện nhiều lần. Các phần tử trong List nên tuân thủ việc ghi đè phương thức equals() để đảm bảo so sánh chính xác.

Biến thể phổ biến

• ArrayList: Được xây dựng trên mảng động, tối ưu cho việc truy cập ngẫu nhiên (random access) nhưng chậm hơn khi chèn/xóa ở giữa danh sách.
• LinkedList: Sử dụng cấu trúc liên kết đôi, mạnh mẽ về thao tác chèn và xóa ở vị trí bất kỳ, tuy nhiên tốc độ truy cập trực tiếp theo chỉ mục thấp hơn.
• Vector: Tương tự ArrayList nhưng đã lỗi thời do cơ chế đồng bộ hóa cổ hủ.

So sánh ArrayList và LinkedList

Hệ thống Đếm và Loại trừ Trùng lặp (Set)

Set đặc trưng bởi tính chất không cho phép tồn tại hai phần tử giống nhau. Để hoạt động hiệu quả, các đối tượng đưa vào Set bắt buộc phải override hai phương thức hashCode() và equals().

• HashSet: Sử dụng bảng băm để tối ưu tìm kiếm, không đảm bảo thứ tự cụ thể.
• LinkedHashSet: Kết hợp Hash table và danh sách liên kết, duy trì đúng thứ tự chèn vào.
• TreeSet: Sắp xếp dữ liệu theo cây đỏ-đen (Red-Black Tree). Yêu cầu phần tử thực thi giao diện Comparable hoặc cung cấp Comparator.

Bản đồ (Map) và Cơ chế Băm

Map lưu trữ dữ liệu theo cặp, trong đó Key phải là duy nhất. Hiệu suất phụ thuộc vào cách lựa chọn Map phù hợp.

• HashMap: Phổ biến nhất, hỗ trợ Key là null, không sắp xếp. Dựa trên thuật toán Hash Table.
• TreeMap: Tự động sắp xếp Key theo thứ tự tăng dần hoặc giảm dần dựa trên Comparable/Comparator.
• LinkedHashMap: Giữ nguyên thứ tự chèn (Insertion order) hoặc LRU (Least Recently Used).
• ConcurrentHashMap: An toàn luồng cho môi trường đa nhân, không sử dụng khóa toàn cục như Hashtable.

Cơ chế hoạt động của HashMap: Khi put(), nó tính toán địa chỉ ô nhớ bằng hashcode của Key. Nếu có xung đột hash (collision), nó tạo chuỗi liên kết tại ô đó. Phương thức get() ngược lại quá trình này để tìm giá trị tương ứng.

Vấn đề An toàn khi Lặp (Iteration Safety)

Một lỗi phổ biến xảy ra khi người lập trình cố gắng sửa đổi cấu trúc tập hợp trong quá trình đang lặp qua nó bằng vòng for-traditional hoặc for-each không đúng cách.

Ví dụ về lỗi ConcurrentModificationException

Việc sử dụng list.remove() trực tiếp bên trong vòng lặp foreach sẽ kích hoạt cơ chế kiểm tra bảo mật fail-fast của Iterator.

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

public class RemovalErrorDemo {
    public static void main(String[] args) {
        List<String> dataBuffer = new ArrayList<>();
        dataBuffer.add("Alpha");
        dataBuffer.add("Beta");
        dataBuffer.add("Gamma");
        dataBuffer.add("Delta");

        // Cách làm NGUY HIỂM: Gây ra ConcurrentModificationException
        for (String item : dataBuffer) {
            // Gọi remove trực tiếp lên list gốc thay vì qua Iterator
            if (item.equals("Beta")) {
                dataBuffer.remove(item); 
            }
        }
    }
}

Nội bộ của ArrayList giữ một biến đếm modCount. Khi tạo Iterator, nó lưu giá trị mong đợi expectedModCount. Nếu bạn sửa list mà không thông báo cho Iterator biết, hai giá trị này lệch nhau và lỗi sẽ được ném ra.

Giải pháp an toàn

Sử dụng phương thức remove() của đối tượng Iterator hoặc lặp ngược chiều chỉ số.

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

public class SafeRemovalStrategy {
    public static void main(String[] args) {
        List<String> targetData = new ArrayList<>();
        targetData.add("Node1");
        targetData.add("Node2");
        targetData.add("Node3");

        // Phương án 1: Dùng Iterator
        Iterator<String> iterator = targetData.iterator();
        while (iterator.hasNext()) {
            String current = iterator.next();
            if (current.equals("Node2")) {
                // Gọi remove trên iterator để cập nhật modCount
                iterator.remove(); 
            }
        }

        // Phương án 2: Lặp ngược (Reverse Loop)
        // Không cần sửa index vì xóa phần tử cuối không ảnh hưởng đến index đầu
        for (int i = targetData.size() - 1; i >= 0; i--) {
            if ("Node1".equals(targetData.get(i))) {
                targetData.remove(i);
            }
        }
    }
}

Danh sách ngăn xếp (Stack) và Hàng đợi (Queue)

Stack hoạt động theo nguyên tắc LIFO (Last In First Out). Mặc dù lớp Stack cũ vẫn tồn tại, nhưng khuyên dùng ArrayDeque vì hiệu năng tốt hơn. Nó cung cấp các phương thức như push() để thêm và pop() để lấy.

Queue hoạt động FIFO (First In First Out). Giao diện Queue cung cấp các phương thức chuẩn hóa như offer() (thêm), peek() (xem đầu tiên không xóa), và poll() (xóa và trả về).

Công cụ tiện ích Collections

Lớp công cụ Collections giúp thao tác phức tạp dễ dàng hơn:

• Unmodifiable: Tạo một lớp vỏ chỉ đọc quanh tập hợp. Mọi nỗ lực sửa đổi đều bị chặn.
• Synchronized: Bao bọc tập hợp để đảm bảo an toàn luồng trong môi trường đa nhiệm.

Chiến lược Fail-Fast và Fail-Safe

Trong Java, các tập hợp thuộc java.util thường áp dụng cơ chế Fail-Fast. Chúng nhạy cảm với sự thay đổi cấu trúc khi đang lặp và sẽ bắn ra ngoại lệ nếu phát hiện sự không khớp về trạng thái sửa đổi.

Ngược lại, các tập hợp trong java.util.concurrent (như CopyOnWriteArrayList) thường là Fail-Safe. Chúng hoạt động trên bản sao chép của dữ liệu, do đó không bị ảnh hưởng bởi các thay đổi diễn ra trên nguồn gốc trong quá trình lặp.