Bài 11: COLLECTION FRAMEWORK – LÀM CHỦ DỮ LIỆU NHÓM VỚI LIST VÀ ARRAYLIST

Chào các nhà quản lý dữ liệu tương lai! Hôm nay chúng ta sẽ khám phá một trong những công cụ mạnh mẽ nhất trong Java – Collection Framework. Đặc biệt, chúng ta sẽ đi sâu vào List và ArrayList – những cấu trúc dữ liệu không thể thiếu trong mọi ứng dụng Java!

I. PHẦN LÝ THUYẾT

1. Vấn đề của mảng (Array) thông thường

Trước khi có Collection, chúng ta dùng mảng:

String[] danhSach = new String[5];  // Cố định 5 phần tử
danhSach[0] = "A";
// Kích thước cố định, không thể thay đổi!

Nhược điểm của Array:

  • Kích thước cố định khi khai báo
  • Không có sẵn các phương thức tiện ích (thêm, xóa, tìm kiếm…)
  • Chỉ chứa được kiểu dữ liệu đồng nhất (trừ khi dùng Object[])

2. Collection Framework – “Bộ sưu tập” thông minh

Collection Framework là một kiến trúc thống nhất để lưu trữ và thao tác với nhóm đối tượng. Nó bao gồm:

  1. Interfaces: Định nghĩa kiểu collection (List, Set, Queue, Map)
  2. Implementations: Các lớp cụ thể (ArrayList, LinkedList, HashSet…)
  3. Algorithms: Các phương thức tiện ích (sắp xếp, tìm kiếm…)

3. Cấu trúc phân cấp Collection Framework

Collection Interface
├── List Interface (cho phép trùng lặp, có thứ tự)
│   ├── ArrayList (mảng động)
│   ├── LinkedList (danh sách liên kết)
│   └── Vector (đồng bộ hóa)
├── Set Interface (không trùng lặp)
│   ├── HashSet
│   ├── TreeSet
│   └── LinkedHashSet
└── Queue Interface (hàng đợi)
    ├── PriorityQueue
    └── LinkedList

Map Interface (không kế thừa Collection)
├── HashMap
├── TreeMap
└── LinkedHashMap

4. List Interface – Danh sách có thứ tự

List là collection:

  • Có thứ tự (giữ nguyên thứ tự khi thêm vào)
  • Cho phép phần tử trùng lặp
  • Có chỉ số (index) truy cập theo vị trí
  • Cho phép phần tử null

5. ArrayList – “Mảng thông minh”

ArrayList là implementation của List:

  • Sử dụng mảng động bên trong
  • Tự động mở rộng kích thước khi cần
  • Truy cập nhanh theo chỉ số (O(1))
  • Chèn/xóa chậm ở giữa (O(n))

Cơ chế mở rộng của ArrayList:

  • Ban đầu: dung lượng mặc định 10
  • Khi đầy: tạo mảng mới = mảng cũ × 1.5 + 1
  • Copy toàn bộ phần tử sang mảng mới

6. Generic trong Collection – An toàn kiểu dữ liệu

Trước Java 5, Collection chứa Object → cần ép kiểu. Từ Java 5 có Generics:

// Cũ (không an toàn)
List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0);  // Ép kiểu

// Mới (an toàn type-safe)
List<String> list = new ArrayList<>();
list.add("Hello");
String s = list.get(0);  // Không cần ép kiểu

7. Các phương thức quan trọng của List/ArrayList

Dưới đây là các phương thức phổ biến nhất của List (được triển khai bởi ArrayList):

A. Thao tác cơ bản

  1. add(E element): Thêm phần tử vào cuối danh sách
  2. add(int index, E element): Chèn phần tử tại vị trí chỉ định
  3. get(int index): Lấy phần tử tại vị trí chỉ định
  4. set(int index, E element): Thay thế phần tử tại vị trí chỉ định
  5. remove(int index): Xóa phần tử tại vị trí chỉ định
  6. remove(Object o): Xóa phần tử đầu tiên bằng đối tượng chỉ định
  7. size(): Trả về số phần tử trong danh sách
  8. isEmpty(): Kiểm tra danh sách có rỗng không
  9. clear(): Xóa tất cả phần tử

B. Tìm kiếm

  1. contains(Object o): Kiểm tra phần tử có tồn tại không
  2. indexOf(Object o): Tìm vị trí đầu tiên của phần tử
  3. lastIndexOf(Object o): Tìm vị trí cuối cùng của phần tử

C. Chuyển đổi

  1. toArray(): Chuyển danh sách thành mảng Object[]
  2. toArray(T[] a): Chuyển danh sách thành mảng kiểu T

D. Các phương thức khác

  1. subList(int fromIndex, int toIndex): Trả về view của một phần danh sách
  2. iterator(): Trả về iterator để duyệt danh sách
  3. listIterator(): Trả về list iterator (có thể duyệt ngược)

II. PHẦN THỰC HÀNH

Ví dụ 1: ArrayList cơ bản – Minh họa các phương thức

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

public class ArrayListCoBan {
    public static void main(String[] args) {
        System.out.println("=== ARRAYLIST CƠ BẢN - MINH HỌA CÁC PHƯƠNG THỨC ===\n");
        
        // 1. Khai báo ArrayList với Generics
        List<String> danhSachTen = new ArrayList<>();
        
        // 2. Thêm phần tử - add()
        System.out.println("--- THÊM PHẦN TỬ ---");
        danhSachTen.add("Nguyễn Văn A");
        danhSachTen.add("Trần Thị B");
        danhSachTen.add("Lê Văn C");
        
        // Thêm tại vị trí cụ thể - add(index, element)
        danhSachTen.add(1, "Phạm Thị D"); // Chèn vào vị trí 1
        
        System.out.println("Danh sách sau khi thêm: " + danhSachTen);
        
        // 3. Lấy kích thước - size()
        System.out.println("\n--- KÍCH THƯỚC ---");
        System.out.println("Số phần tử: " + danhSachTen.size());
        
        // 4. Truy cập phần tử - get()
        System.out.println("\n--- TRUY CẬP PHẦN TỬ ---");
        System.out.println("Phần tử thứ 0: " + danhSachTen.get(0));
        System.out.println("Phần tử thứ 2: " + danhSachTen.get(2));
        
        // 5. Cập nhật phần tử - set()
        System.out.println("\n--- CẬP NHẬT PHẦN TỬ ---");
        System.out.println("Trước khi cập nhật: " + danhSachTen.get(1));
        danhSachTen.set(1, "Trần Thị B (Đã đổi tên)");
        System.out.println("Sau khi cập nhật: " + danhSachTen.get(1));
        
        // 6. Tìm kiếm - contains(), indexOf()
        System.out.println("\n--- TÌM KIẾM ---");
        System.out.println("Có 'Lê Văn C' không? " + danhSachTen.contains("Lê Văn C"));
        System.out.println("Vị trí của 'Lê Văn C': " + danhSachTen.indexOf("Lê Văn C"));
        System.out.println("Vị trí của 'Không tồn tại': " + danhSachTen.indexOf("Không tồn tại"));
        
        // 7. Xóa phần tử - remove()
        System.out.println("\n--- XÓA PHẦN TỬ ---");
        System.out.println("Trước khi xóa: " + danhSachTen);
        
        // Xóa theo chỉ số
        String removedByIndex = danhSachTen.remove(0);
        System.out.println("Đã xóa (theo index 0): " + removedByIndex);
        
        // Xóa theo đối tượng
        boolean removedByObject = danhSachTen.remove("Lê Văn C");
        System.out.println("Xóa 'Lê Văn C' thành công? " + removedByObject);
        
        System.out.println("Sau khi xóa: " + danhSachTen);
        
        // 8. Kiểm tra rỗng - isEmpty()
        System.out.println("\n--- KIỂM TRA RỖNG ---");
        System.out.println("Danh sách có rỗng không? " + danhSachTen.isEmpty());
        
        // 9. Duyệt danh sách
        System.out.println("\n--- DUYỆT DANH SÁCH ---");
        System.out.println("Cách 1: For thông thường");
        for (int i = 0; i < danhSachTen.size(); i++) {
            System.out.println("Vị trí " + i + ": " + danhSachTen.get(i));
        }
        
        System.out.println("\nCách 2: For-each");
        for (String ten : danhSachTen) {
            System.out.println("Tên: " + ten);
        }
        
        System.out.println("\nCách 3: ForEach với Lambda (Java 8+)");
        danhSachTen.forEach(ten -> System.out.println("Tên: " + ten));
        
        // 10. Chuyển đổi sang mảng - toArray()
        System.out.println("\n--- CHUYỂN ĐỔI SANG MẢNG ---");
        String[] mangTen = danhSachTen.toArray(new String[0]);
        System.out.println("Mảng chuyển đổi:");
        for (String ten : mangTen) {
            System.out.println(ten);
        }
        
        // 11. Xóa toàn bộ - clear()
        System.out.println("\n--- XÓA TOÀN BỘ ---");
        danhSachTen.clear();
        System.out.println("Sau khi clear, kích thước: " + danhSachTen.size());
        System.out.println("Danh sách có rỗng không? " + danhSachTen.isEmpty());
    }
}

Ví dụ 2: ArrayList với đối tượng tùy chỉnh

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

// Lớp SinhVien
class SinhVien {
    private String maSV;
    private String hoTen;
    private double diemTB;
    
    public SinhVien(String maSV, String hoTen, double diemTB) {
        this.maSV = maSV;
        this.hoTen = hoTen;
        this.diemTB = diemTB;
    }
    
    // Getter
    public String getMaSV() { return maSV; }
    public String getHoTen() { return hoTen; }
    public double getDiemTB() { return diemTB; }
    
    @Override
    public String toString() {
        return String.format("Mã: %-8s | Tên: %-20s | Điểm: %.1f", maSV, hoTen, diemTB);
    }
}
// Lớp quản lý sinh viên sử dụng ArrayList
public class QuanLySinhVien {
    private List<SinhVien> danhSachSV;
    
    public QuanLySinhVien() {
        danhSachSV = new ArrayList<>();
    }
    
    // Thêm sinh viên - add()
    public void themSinhVien(SinhVien sv) {
        danhSachSV.add(sv);
        System.out.println("Đã thêm: " + sv.getHoTen());
    }
    
    // Tìm sinh viên theo mã - sử dụng get() và vòng lặp
    public SinhVien timTheoMa(String maSV) {
        for (SinhVien sv : danhSachSV) {
            if (sv.getMaSV().equals(maSV)) {
                return sv;
            }
        }
        return null;
    }
    
    // Tìm sinh viên có điểm cao nhất
    public SinhVien timDiemCaoNhat() {
        if (danhSachSV.isEmpty()) {
            return null;
        }
        
        SinhVien svCaoNhat = danhSachSV.get(0);
        for (SinhVien sv : danhSachSV) {
            if (sv.getDiemTB() > svCaoNhat.getDiemTB()) {
                svCaoNhat = sv;
            }
        }
        return svCaoNhat;
    }
    
    // Tính điểm trung bình của cả lớp
    public double tinhDiemTrungBinhLop() {
        if (danhSachSV.isEmpty()) {
            return 0;
        }
        
        double tong = 0;
        for (SinhVien sv : danhSachSV) {
            tong += sv.getDiemTB();
        }
        return tong / danhSachSV.size();
    }
    
    // Lọc sinh viên có điểm >= điểm cho trước
    public List<SinhVien> locSinhVienTheoDiem(double diemToiThieu) {
        List<SinhVien> ketQua = new ArrayList<>();
        for (SinhVien sv : danhSachSV) {
            if (sv.getDiemTB() >= diemToiThieu) {
                ketQua.add(sv);
            }
        }
        return ketQua;
    }
    
    // Sắp xếp theo điểm (giảm dần) - sử dụng thuật toán đơn giản
    public void sapXepTheoDiem() {
        // Sử dụng bubble sort
        for (int i = 0; i < danhSachSV.size() - 1; i++) {
            for (int j = 0; j < danhSachSV.size() - i - 1; j++) {
                if (danhSachSV.get(j).getDiemTB() < danhSachSV.get(j + 1).getDiemTB()) {
                    // Hoán đổi
                    SinhVien temp = danhSachSV.get(j);
                    danhSachSV.set(j, danhSachSV.get(j + 1));
                    danhSachSV.set(j + 1, temp);
                }
            }
        }
    }
    
    // Hiển thị toàn bộ sinh viên
    public void hienThiDanhSach() {
        if (danhSachSV.isEmpty()) {
            System.out.println("Danh sách sinh viên trống!");
            return;
        }
        
        System.out.println("\n=== DANH SÁCH SINH VIÊN ===");
        System.out.println(String.format("%-5s %-8s %-20s %-10s", 
            "STT", "Mã SV", "Họ tên", "Điểm TB"));
        System.out.println("=".repeat(50));
        
        for (int i = 0; i < danhSachSV.size(); i++) {
            SinhVien sv = danhSachSV.get(i);
            System.out.println(String.format("%-5d %-8s %-20s %-10.1f", 
                i + 1, sv.getMaSV(), sv.getHoTen(), sv.getDiemTB()));
        }
    }
    
    // Xóa sinh viên theo mã - remove()
    public boolean xoaSinhVien(String maSV) {
        for (int i = 0; i < danhSachSV.size(); i++) {
            if (danhSachSV.get(i).getMaSV().equals(maSV)) {
                SinhVien svBiXoa = danhSachSV.remove(i);
                System.out.println("Đã xóa: " + svBiXoa.getHoTen());
                return true;
            }
        }
        System.out.println("Không tìm thấy sinh viên với mã: " + maSV);
        return false;
    }
    
    // Sử dụng subList()
    public void hienThiHaiSinhVienDauTien() {
        if (danhSachSV.size() >= 2) {
            List<SinhVien> subList = danhSachSV.subList(0, 2);
            System.out.println("\nHai sinh viên đầu tiên:");
            subList.forEach(System.out::println);
        }
    }
}
// Chương trình chính
public class MainQuanLySinhVien {
    public static void main(String[] args) {
        System.out.println("=== HỆ THỐNG QUẢN LÝ SINH VIÊN VỚI ARRAYLIST ===\n");
        
        QuanLySinhVien qlsv = new QuanLySinhVien();
        
        // Thêm sinh viên
        qlsv.themSinhVien(new SinhVien("SV001", "Nguyễn Văn A", 8.5));
        qlsv.themSinhVien(new SinhVien("SV002", "Trần Thị B", 7.2));
        qlsv.themSinhVien(new SinhVien("SV003", "Lê Văn C", 6.8));
        qlsv.themSinhVien(new SinhVien("SV004", "Phạm Thị D", 9.1));
        qlsv.themSinhVien(new SinhVien("SV005", "Hoàng Văn E", 5.5));
        
        // Hiển thị danh sách
        qlsv.hienThiDanhSach();
        
        // Tìm sinh viên
        System.out.println("\n=== TÌM KIẾM SINH VIÊN ===");
        SinhVien sv = qlsv.timTheoMa("SV003");
        System.out.println("Tìm SV003: " + (sv != null ? sv : "Không tìm thấy"));
        
        // Tìm điểm cao nhất
        System.out.println("\n=== SINH VIÊN ĐIỂM CAO NHẤT ===");
        SinhVien svCaoNhat = qlsv.timDiemCaoNhat();
        System.out.println(svCaoNhat != null ? svCaoNhat : "Không có sinh viên");
        
        // Tính điểm trung bình lớp
        System.out.println("\n=== ĐIỂM TRUNG BÌNH LỚP ===");
        System.out.printf("Điểm TB lớp: %.2f\n", qlsv.tinhDiemTrungBinhLop());
        
        // Lọc sinh viên
        System.out.println("\n=== SINH VIÊN CÓ ĐIỂM >= 8.0 ===");
        List<SinhVien> svGioi = qlsv.locSinhVienTheoDiem(8.0);
        if (!svGioi.isEmpty()) {
            svGioi.forEach(System.out::println);
        } else {
            System.out.println("Không có sinh viên nào đạt điểm >= 8.0");
        }
        
        // Sắp xếp
        System.out.println("\n=== DANH SÁCH SAU KHI SẮP XẾP (GIẢM DẦN THEO ĐIỂM) ===");
        qlsv.sapXepTheoDiem();
        qlsv.hienThiDanhSach();
        
        // Xóa sinh viên
        System.out.println("\n=== XÓA SINH VIÊN ===");
        qlsv.xoaSinhVien("SV002");
        qlsv.hienThiDanhSach();
        
        // Sử dụng subList
        qlsv.hienThiHaiSinhVienDauTien();
    }
}

Ví dụ 3: So sánh ArrayList với LinkedList và Vector

import java.util.*;

public class SoSanhCacList {
    public static void main(String[] args) {
        System.out.println("=== SO SÁNH ARRAYLIST, LINKEDLIST, VECTOR ===\n");
        
        // 1. Tạo các loại List
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();
        List<String> vector = new Vector<>();
        
        // 2. Test tốc độ thêm phần tử ở cuối
        System.out.println("=== TỐC ĐỘ THÊM Ở CUỐI ===");
        
        long startTime = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            arrayList.add("Element " + i);
        }
        long arrayListTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            linkedList.add("Element " + i);
        }
        long linkedListTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            vector.add("Element " + i);
        }
        long vectorTime = System.nanoTime() - startTime;
        
        System.out.printf("ArrayList:  %10d ns\n", arrayListTime);
        System.out.printf("LinkedList: %10d ns\n", linkedListTime);
        System.out.printf("Vector:     %10d ns\n", vectorTime);
        
        // 3. Test tốc độ truy cập ngẫu nhiên
        System.out.println("\n=== TỐC ĐỘ TRUY CẬP NGẪU NHIÊN ===");
        
        startTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            arrayList.get(i * 10);
        }
        arrayListTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            linkedList.get(i * 10);
        }
        linkedListTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            vector.get(i * 10);
        }
        vectorTime = System.nanoTime() - startTime;
        
        System.out.printf("ArrayList:  %10d ns (NHANH NHẤT)\n", arrayListTime);
        System.out.printf("LinkedList: %10d ns (CHẬM)\n", linkedListTime);
        System.out.printf("Vector:     %10d ns\n", vectorTime);
        
        // 4. Test tốc độ chèn ở đầu
        System.out.println("\n=== TỐC ĐỘ CHÈN Ở ĐẦU ===");
        
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            arrayList.add(0, "New Element");
        }
        arrayListTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            linkedList.add(0, "New Element");
        }
        linkedListTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            vector.add(0, "New Element");
        }
        vectorTime = System.nanoTime() - startTime;
        
        System.out.printf("ArrayList:  %10d ns (CHẬM)\n", arrayListTime);
        System.out.printf("LinkedList: %10d ns (NHANH NHẤT)\n", linkedListTime);
        System.out.printf("Vector:     %10d ns\n", vectorTime);
        
        // 5. Đồng bộ hóa
        System.out.println("\n=== ĐỒNG BỘ HÓA (THREAD-SAFE) ===");
        System.out.println("ArrayList:  KHÔNG đồng bộ hóa (nhanh hơn, dùng cho single-thread)");
        System.out.println("LinkedList: KHÔNG đồng bộ hóa");
        System.out.println("Vector:     CÓ đồng bộ hóa (chậm hơn, dùng cho multi-thread)");
        
        // 6. Tóm tắt
        System.out.println("\n=== TÓM TẮT - KHI NÀO DÙNG CÁI NÀO? ===");
        System.out.println("Dùng ArrayList khi:");
        System.out.println("  - Truy cập ngẫu nhiên nhiều (get, set)");
        System.out.println("  - Thêm/xóa chủ yếu ở cuối danh sách");
        System.out.println("  - Ứng dụng single-thread");
        
        System.out.println("\nDùng LinkedList khi:");
        System.out.println("  - Thêm/xóa ở đầu hoặc giữa danh sách nhiều");
        System.out.println("  - Cần hàng đợi (Queue) hoặc ngăn xếp (Stack)");
        System.out.println("  - Không cần truy cập ngẫu nhiên thường xuyên");
        
        System.out.println("\nDùng Vector khi:");
        System.out.println("  - Cần thread-safety (multi-thread)");
        System.out.println("  - Tương thích với code cũ (Java 1.0)");
    }
}

III. CÂU HỎI VÀ BÀI TẬP

Phần A: Câu hỏi lý thuyết (5 phút)

  1. Câu 1: ArrayList và Array thông thường khác nhau như thế nào?
  2. Câu 2: Tại sao nên sử dụng Generics (List<String>) thay vì raw type (List)?
  3. Câu 3: Khi nào thì ArrayList tự động mở rộng kích thước? Cơ chế mở rộng thế nào?
  4. Câu 4: Phân biệt size() và capacity() trong ArrayList?
  5. Câu 5: Khi nào nên dùng ArrayList, khi nào nên dùng LinkedList?

Phần B: Bài tập thực hành (25 phút)

Bài 1: Quản lý sản phẩm

Tạo hệ thống quản lý sản phẩm với ArrayList:

  1. Tạo lớp SanPham với: maSP, tenSP, gia, soLuong
  2. Tạo lớp QuanLySanPham với ArrayList<SanPham>
  3. Các chức năng:
    • Thêm sản phẩm
    • Xóa sản phẩm theo mã
    • Tìm sản phẩm theo tên (tìm gần đúng)
    • Sắp xếp sản phẩm theo giá (tăng dần/giảm dần)
    • Tính tổng giá trị kho hàng
    • Liệt kê sản phẩm sắp hết hàng (số lượng < 10)

Bài 2: Xử lý danh sách số

Viết chương trình thao tác với ArrayList<Integer>:

  1. Nhập danh sách số nguyên từ người dùng
  2. Loại bỏ các số trùng lặp (giữ lại 1 lần xuất hiện đầu)
  3. Tìm số lớn thứ 2 trong danh sách
  4. Tính trung bình cộng các số chẵn
  5. Tách danh sách thành 2: số chẵn và số lẻ
  6. Đảo ngược danh sách (không dùng Collections.reverse)

Bài 3: Hệ thống đặt hàng

Xây dựng hệ thống đơn hàng:

  1. Tạo lớp DonHang với: maDH, tenKH, danhSachSanPham (List<String>), tongTien
  2. Tạo lớp QuanLyDonHang với ArrayList<DonHang>
  3. Các chức năng:
    • Thêm đơn hàng
    • Tìm đơn hàng có giá trị cao nhất
    • Thống kê số lượng đơn hàng theo khách hàng
    • Tính tổng doanh thu
    • Sắp xếp đơn hàng theo ngày (giả sử thêm thuộc tính ngayDat)

Phần C: Thử thách nâng cao (20 phút)

Bài 4: Trò chơi Memory Game

Tạo game lật bài trí nhớ sử dụng ArrayList:

  1. Tạo lớp Card với: giaTri, trangThai (đã lật/chưa lật)
  2. Khởi tạo danh sách 8 cặp bài (16 lá) xáo trộn ngẫu nhiên
  3. Hiển thị bảng 4×4 (ẩn/mở)
  4. Cho phép người chơi chọn 2 lá để lật
  5. Kiểm tra nếu 2 lá giống nhau thì giữ nguyên trạng thái mở
  6. Kết thúc khi tất cả lá được lật
  7. Tính điểm dựa trên số lần lật

Bài 5: Hệ thống quản lý thư viện nâng cao

Phát triển hệ thống bài 6 với ArrayList:

  1. Tạo lớp TaiLieu abstract, các lớp Sach, Bao, TapChi
  2. Tạo lớp ThanhVien với danh sách tài liệu đang mượn
  3. Tạo lớp ThuVien quản lý ArrayList<TaiLieu> và ArrayList<ThanhVien>
  4. Các chức năng:
    • Mượn/trả tài liệu (kiểm tra điều kiện)
    • Tìm kiếm tài liệu theo nhiều tiêu chí
    • Thống kê tài liệu theo loại
    • Hiển thị tài liệu được mượn nhiều nhất
    • Gợi ý tài liệu dựa trên lịch sử mượn

IV. TÓM TẮT BÀI HỌC

  • Collection Framework: Kiến trúc thống nhất để quản lý nhóm đối tượng
  • List Interface: Danh sách có thứ tự, cho phép trùng lặp và truy cập theo chỉ số
  • ArrayList: Implementation phổ biến nhất của List, dùng mảng động
  • Ưu điểm ArrayList: Truy cập nhanh theo index (O(1)), dễ sử dụng
  • Nhược điểm ArrayList: Chèn/xóa chậm ở giữa (O(n)), kích thước tự động mở rộng tốn chi phí
  • Generics: Đảm bảo an toàn kiểu dữ liệu, không cần ép kiểu
  • Các phương thức quan trọng: add(), get(), remove(), size(), contains(), indexOf()

P.S.: Thử thách đặc biệt: Hãy tạo một lớp MyArrayList<E> của riêng bạn, implement các phương thức cơ bản của List (add, get, remove, size) mà không dùng ArrayList có sẵn của Java!

Comments are closed.