HashSet

1. HashSet là gì?

HashSet<E> lưu trữ một tập hợp phần tử không trùng lặp - nếu thêm một giá trị đã tồn tại, nó sẽ bị bỏ qua (không có lỗi, cũng không thêm bản sao):

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

Set<String> uniqueNames = new HashSet<>();

uniqueNames.add("An");
uniqueNames.add("Bình");
uniqueNames.add("An"); // trùng lặp -> bị bỏ qua, không thêm lần 2

System.out.println(uniqueNames.size()); // 2, không phải 3
System.out.println(uniqueNames);        // [An, Bình] (thứ tự không đảm bảo)

2. Các thao tác thường dùng

Set<Integer> numbers = new HashSet<>();

numbers.add(1);
numbers.add(2);
numbers.add(3);

System.out.println(numbers.contains(2)); // true - kiểm tra tồn tại RẤT nhanh (O(1))
numbers.remove(2);
System.out.println(numbers.size());       // 2

3. Loại bỏ phần tử trùng lặp từ một danh sách

Ứng dụng thực tế phổ biến nhất: dùng HashSet để lọc trùng lặp từ một List:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

List<Integer> numbers = List.of(1, 2, 2, 3, 3, 3, 4);
Set<Integer> unique = new HashSet<>(numbers); // tạo Set từ List -> tự động loại trùng
List<Integer> result = new ArrayList<>(unique); // chuyển ngược lại thành List nếu cần

System.out.println(unique); // [1, 2, 3, 4] (thứ tự không đảm bảo)

4. Không đảm bảo thứ tự

Giống HashMap, HashSet không đảm bảo thứ tự phần tử khi duyệt. Nếu cần giữ thứ tự thêm vào, dùng LinkedHashSet; nếu cần thứ tự sắp xếp, dùng TreeSet:

Set<String> insertionOrder = new LinkedHashSet<>(); // giữ đúng thứ tự thêm vào
Set<Integer> sorted = new TreeSet<>();              // luôn duyệt theo thứ tự tăng dần

5. Các phép toán tập hợp

Set<Integer> a = new HashSet<>(Set.of(1, 2, 3));
Set<Integer> b = new HashSet<>(Set.of(2, 3, 4));

Set<Integer> union = new HashSet<>(a);
union.addAll(b); // hợp: {1, 2, 3, 4}

Set<Integer> intersection = new HashSet<>(a);
intersection.retainAll(b); // giao: {2, 3}

Set<Integer> difference = new HashSet<>(a);
difference.removeAll(b); // hiệu: {1}

Tổng kết

• HashSet<E> lưu tập hợp phần tử không trùng lặp, kiểm tra tồn tại rất nhanh
• Cách nhanh nhất để loại trùng lặp một List: new HashSet<>(list)
• Không đảm bảo thứ tự - dùng LinkedHashSet/TreeSet nếu cần giữ hoặc sắp xếp thứ tự
• addAll(), retainAll(), removeAll() để tính hợp, giao, hiệu của hai tập hợp