Trong Java, Collections Framework cung cấp một bộ công cụ mạnh mẽ để quản lý và xử lý các tập hợp dữ liệu. Các interfaces cơ bản của Java Collections là nền tảng cho việc tổ chức và thao tác với dữ liệu, giúp lập trình viên dễ dàng hơn trong việc phát triển ứng dụng. Bài viết này sẽ trình bày chi tiết các interfaces cơ bản trong Java Collections từ cơ bản đến nâng cao.

1. Collection

Khái niệm

Collection là giao diện cơ sở cho tất cả các kiểu tập hợp trong Java. Nó định nghĩa các phương thức cơ bản để thao tác với các phần tử trong tập hợp, cho phép bạn thực hiện các thao tác như thêm, xóa và kiểm tra sự tồn tại của phần tử.

Các phương thức chính

  • add(E e): Thêm một phần tử vào tập hợp.
  • remove(Object o): Xóa một phần tử khỏi tập hợp.
  • contains(Object o): Kiểm tra xem tập hợp có chứa phần tử hay không.
  • size(): Trả về số lượng phần tử trong tập hợp.
  • isEmpty(): Kiểm tra xem tập hợp có rỗng hay không.
  • iterator(): Trả về một iterator để duyệt qua các phần tử trong tập hợp.

Ví dụ sử dụng Collection

import java.util.ArrayList;
import java.util.Collection;

public class CollectionExample {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        collection.add("Java");
        collection.add("Python");
        collection.add("C++");
        
        System.out.println("Số lượng phần tử: " + collection.size());
        System.out.println("Có chứa 'Java'? " + collection.contains("Java"));
        
        collection.remove("Python");
        System.out.println("Sau khi xóa 'Python': " + collection);
    }
}

2. List

Khái niệm

List là một giao diện mở rộng từ Collection, đại diện cho một tập hợp các phần tử có thứ tự. Các phần tử trong một List có thể trùng lặp và có thể truy cập thông qua chỉ mục.

Các lớp chính

  • ArrayList: Một danh sách có thể thay đổi kích thước, cho phép truy cập nhanh đến các phần tử thông qua chỉ mục.
  • LinkedList: Một danh sách liên kết cho phép thêm hoặc xóa phần tử nhanh chóng, nhưng truy cập chậm hơn so với ArrayList.
  • Vector: Tương tự như ArrayList, nhưng được đồng bộ hóa, phù hợp cho các ứng dụng đa luồng.

Ví dụ sử dụng List

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

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("Java"); // Phần tử trùng lặp
        
        System.out.println("Danh sách: " + list);
        System.out.println("Phần tử tại chỉ mục 1: " + list.get(1));
        
        list.remove("Python");
        System.out.println("Sau khi xóa 'Python': " + list);
    }
}

3. Set

Khái niệm

Set là một giao diện mở rộng từ Collection, đại diện cho một tập hợp các phần tử không trùng lặp. Điều này có nghĩa là một Set không cho phép các phần tử giống nhau.

Các lớp chính

  • HashSet: Một tập hợp không có thứ tự, nhanh chóng trong việc thêm và tìm kiếm phần tử.
  • LinkedHashSet: Tương tự như HashSet, nhưng duy trì thứ tự thêm các phần tử.
  • TreeSet: Một tập hợp được sắp xếp theo thứ tự tự nhiên hoặc theo một comparator.

Ví dụ sử dụng Set

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Java");
        set.add("Python");
        set.add("Java"); // Không thêm được vì trùng lặp
        
        System.out.println("Tập hợp: " + set);
        System.out.println("Có chứa 'Python'? " + set.contains("Python"));
        
        set.remove("Java");
        System.out.println("Sau khi xóa 'Java': " + set);
    }
}

4. Queue

Khái niệm

Queue là một giao diện đại diện cho một tập hợp các phần tử theo kiểu FIFO (First-In-First-Out). Tức là, phần tử được thêm vào trước sẽ được lấy ra trước.

Các lớp chính

  • LinkedList: Cũng có thể được sử dụng như một hàng đợi, cho phép thao tác nhanh chóng với các phần tử.
  • PriorityQueue: Hàng đợi cho phép quản lý các phần tử theo thứ tự ưu tiên.

Ví dụ sử dụng Queue

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("Java");
        queue.offer("Python");
        queue.offer("C++");
        
        System.out.println("Hàng đợi: " + queue);
        System.out.println("Phần tử đầu tiên: " + queue.peek());
        
        queue.poll(); // Xóa phần tử đầu tiên
        System.out.println("Sau khi xóa phần tử đầu tiên: " + queue);
    }
}

5. Map

Khái niệm

Map là một giao diện không mở rộng từ Collection, đại diện cho một tập hợp các cặp key-value. Mỗi key trong Map phải là duy nhất, trong khi giá trị có thể trùng lặp.

Các lớp chính

  • HashMap: Một bản đồ không có thứ tự, cho phép truy cập nhanh đến giá trị thông qua key.
  • LinkedHashMap: Tương tự như HashMap, nhưng duy trì thứ tự thêm các cặp key-value.
  • TreeMap: Một bản đồ được sắp xếp theo thứ tự tự nhiên của các key hoặc theo một comparator.

Ví dụ sử dụng Map

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Java", 90);
        map.put("Python", 85);
        map.put("C++", 80);
        
        System.out.println("Bản đồ: " + map);
        System.out.println("Điểm của 'Python': " + map.get("Python"));
        
        map.remove("C++");
        System.out.println("Sau khi xóa 'C++': " + map);
    }
}

6. SortedSet và SortedMap

SortedSet

SortedSet là giao diện mở rộng từ Set, cung cấp khả năng lưu trữ các phần tử theo thứ tự tự nhiên hoặc một bộ so sánh cụ thể.

SortedMap

SortedMap là giao diện mở rộng từ Map, cung cấp khả năng lưu trữ các cặp key-value theo thứ tự tự nhiên của keys hoặc một bộ so sánh cụ thể.

Các lớp chính cho SortedSet và SortedMap:

  • TreeSet (cho SortedSet)
  • TreeMap (cho SortedMap)

Ví dụ sử dụng SortedSet

import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetExample {
    public static void main(String[] args) {
        SortedSet<String> sortedSet = new TreeSet<>();
        sortedSet.add("Java");
        sortedSet.add("Python");
        sortedSet.add("C++");
        
        System.out.println("Sorted Set: " + sortedSet);
    }
}

Ví dụ sử dụng SortedMap

import java.util.SortedMap;
import java.util.TreeMap;

public class SortedMapExample {
    public static void main(String[] args) {
        SortedMap<String, Integer> sortedMap = new TreeMap<>();
        sortedMap.put("Java", 90);
        sortedMap.put("Python", 85);
        sortedMap.put("C++", 80);
        
        System.out.println("Sorted Map: " + sortedMap);
    }
}

Bài viết đã trình bày chi tiết về các interfaces cơ bản của Java Collections, từ Collection cho đến SortedMap. Mỗi giao diện đều có những đặc điểm riêng, phù hợp với các nhu cầu khác nhau trong lập trình. Việc hiểu rõ các interfaces này sẽ giúp bạn tối ưu hóa mã nguồn và quản lý dữ liệu một cách hiệu quả.