Java集合框架之Set的实现类与实战使用详解

// Set 接口核心方法（继承自 Collection）
public interface Set<E> extends Collection<E> {
    // 添加元素（若元素已存在则返回 false）
    boolean add(E e);
    // 批量添加元素
    boolean addAll(Collection<? extends E> c);
    // 删除元素
    boolean remove(Object o);
    // 判断是否包含元素
    boolean contains(Object o);
    // 获取迭代器
    Iterator<E> iterator();
    // 其他方法（size()、isEmpty()、clear() 等）
}

public class HashSet<E> extends AbstractSet<E>
        implements Set<E>, Cloneable, java.io.Serializable {
    // 底层存储核心：HashMap 对象
    private transient HashMap<E, Object> map;
    // 固定的 value 对象，所有 key 都映射到该对象
    private static final Object PRESENT = new Object();
    // 无参构造：创建空的 HashMap
    public HashSet() {
        map = new HashMap<>();
    }
    // 指定初始容量的构造函数
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
    // 指定初始容量和负载因子的构造函数
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
}

public boolean add(E e) {
    // 调用 HashMap 的 put 方法，key 为待添加元素，value 为 PRESENT
    // HashMap 的 put 方法返回 null 表示添加成功（key 不存在），返回旧 value 表示添加失败（key 已存在）
    return map.put(e, PRESENT) == null;
}

public boolean contains(Object o) {
    // 委托给 HashMap 的 containsKey 方法
    return map.containsKey(o);
}

public boolean remove(Object o) {
    // 委托给 HashMap 的 remove 方法，返回 PRESENT 表示删除成功
    return map.remove(o) == PRESENT;
}

class Person {
    private String name;
    private int age;
    // 仅重写 equals()，未重写 hashCode()
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
    // 省略构造函数和 getter/setter
}
// 测试：两个 equals() 相同但 hashCode() 不同的对象
Person p1 = new Person("张三", 20);
Person p2 = new Person("张三", 20);
System.out.println(p1.equals(p2)); // true
System.out.println(p1.hashCode() == p2.hashCode()); // false（Object 类的 hashCode() 基于对象地址）
HashSet<Person> set = new HashSet<>();
set.add(p1);
set.add(p2);
System.out.println(set.size()); // 2（去重失效！）

class Person {
    private String name;
    private int age;
    // 构造函数、getter/setter 省略
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        // 基于 equals() 依赖的属性计算哈希值
        return Objects.hash(name, age);
    }
}
// 测试：去重生效
Person p1 = new Person("张三", 20);
Person p2 = new Person("张三", 20);
HashSet<Person> set = new HashSet<>();
set.add(p1);
set.add(p2);
System.out.println(set.size()); // 1（正确去重）

// 推荐：已知元素约 1000 个，指定初始容量 1334
HashSet<String> set = new HashSet<>(1334);

public class LinkedHashSet<E> extends HashSet<E>
        implements Set<E>, Cloneable, java.io.Serializable {
    // 构造函数：调用父类 HashSet 的构造函数，创建 LinkedHashMap 实例
    public LinkedHashSet() {
        super(16, .75f, true);
    }
    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }
    // 父类 HashSet 中对应的构造函数（包访问权限）
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }
}

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after; // 双向链表的前驱和后继指针
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

// 自定义访问顺序的 LinkedHashSet
class AccessOrderLinkedHashSet<E> extends LinkedHashSet<E> {
    public AccessOrderLinkedHashSet(int initialCapacity, float loadFactor) {
        super(new LinkedHashMap<>(initialCapacity, loadFactor, true));
    }
}
// 测试访问顺序
public class TestAccessOrder {
    public static void main(String[] args) {
        AccessOrderLinkedHashSet<String> set = new AccessOrderLinkedHashSet<>(16, 0.75f);
        set.add("A");
        set.add("B");
        set.add("C");
        System.out.println("初始遍历：" + new ArrayList<>(set)); // [A, B, C]（插入顺序）
        set.contains("B"); // 访问 B 元素
        System.out.println("访问 B 后遍历：" + new ArrayList<>(set)); // [A, C, B]（B 移到尾部）
    }
}

public class TreeSet<E> extends AbstractSet<E>
        implements NavigableSet<E>, Cloneable, java.io.Serializable {
    // 底层存储核心：TreeMap 对象
    private transient NavigableMap<E, Object> m;
    // 固定的 value 对象，与 HashSet 类似
    private static final Object PRESENT = new Object();
    // 构造函数：创建 TreeMap 实例
    public TreeSet() {
        this(new TreeMap<>());
    }
    // 自定义比较器的构造函数
    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }
    TreeSet(NavigableMap<E, Object> m) {
        this.m = m;
    }
}

class Student implements Comparable<Student> {
    private String id;
    private int score;
    // 构造函数、getter/setter 省略
    // 按分数降序排序，分数相同按学号升序排序
    @Override
    public int compareTo(Student o) {
        if (this.score != o.score) {
            return o.score - this.score; // 降序（o.score - this.score）
        }
        return this.id.compareTo(o.id); // 升序
    }
    @Override
    public String toString() {
        return "Student{id='" + id + "', score=" + score + "}";
    }
}
// 测试自然排序
public class TreeSetNaturalSortTest {
    public static void main(String[] args) {
        TreeSet<Student> set = new TreeSet<>();
        set.add(new Student("001", 90));
        set.add(new Student("002", 85));
        set.add(new Student("003", 90));
        set.add(new Student("004", 95));
        // 遍历：按分数降序，分数相同按学号升序
        for (Student s : set) {
            System.out.println(s);
        }
        // 输出结果：
        // Student{id='004', score=95}
        // Student{id='001', score=90}
        // Student{id='003', score=90}
        // Student{id='002', score=85}
    }
}

class Employee {
    private String name;
    private int age;
    // 构造函数、getter/setter、toString 省略
}
// 测试定制排序（按年龄升序）
public class TreeSetCustomSortTest {
    public static void main(String[] args) {
        // 传入 Comparator 匿名内部类（Java 8+ 可简化为 Lambda 表达式）
        TreeSet<Employee> set = new TreeSet<>((e1, e2) -> e1.getAge() - e2.getAge());
        set.add(new Employee("张三", 25));
        set.add(new Employee("李四", 22));
        set.add(new Employee("王五", 28));
        for (Employee e : set) {
            System.out.println(e);
        }
        // 输出结果：
        // Employee{name='李四', age=22}
        // Employee{name='张三', age=25}
        // Employee{name='王五', age=28}
    }
}

public boolean add(E e) {
    // 调用 TreeMap 的 put 方法，key 为元素 e，value 为 PRESENT
    return m.put(e, PRESENT) == null;
}

// 查找小于 e 的最大元素
E lower(E e);
// 查找小于等于 e 的最大元素
E floor(E e);
// 查找大于等于 e 的最小元素
E ceiling(E e);
// 查找大于 e 的最小元素
E higher(E e);
// 删除并返回最小元素
E pollFirst();
// 删除并返回最大元素
E pollLast();
// 获取升序迭代器
Iterator<E> iterator();
// 获取降序迭代器
Iterator<E> descendingIterator();

TreeSet<Integer> set = new TreeSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(40);
System.out.println(set.lower(25)); // 20（小于 25 的最大元素）
System.out.println(set.floor(25)); // 20（小于等于 25 的最大元素）
System.out.println(set.ceiling(25)); // 30（大于等于 25 的最小元素）
System.out.println(set.higher(25)); // 30（大于 25 的最小元素）
System.out.println(set.pollFirst()); // 10（删除最小元素）
System.out.println(set.pollLast()); // 40（删除最大元素）

// 选型：HashSet（高效去重，性能最优）
Set<String> usernames = new HashSet<>();
usernames.add("zhangsan");
usernames.add("lisi");
// 重复添加会失败
usernames.add("zhangsan");
System.out.println(usernames.size()); // 1

// 选型：LinkedHashSet（去重+插入顺序）
Set<String> operationLogs = new LinkedHashSet<>();
operationLogs.add("用户登录");
operationLogs.add("查询数据");
operationLogs.add("修改数据");
operationLogs.add("用户退出");
// 遍历顺序与插入顺序一致
for (String log : operationLogs) {
    System.out.println(log); // 用户登录 → 查询数据 → 修改数据 → 用户退出
}

// 选型：TreeSet（去重+排序+导航方法）
TreeSet<Student> scoreRank = new TreeSet<>((s1, s2) -> s2.getScore() - s1.getScore());
scoreRank.add(new Student("001", 90));
scoreRank.add(new Student("002", 95));
scoreRank.add(new Student("003", 88));
// Top3 查询（升序迭代器取前3个）
Iterator<Student> iterator = scoreRank.iterator();
int count = 0;
System.out.println("成绩排行榜 Top3：");
while (iterator.hasNext() && count < 3) {
    System.out.println(++count + "：" + iterator.next());
}

import java.util.LinkedHashSet;
import java.util.Set;
/**
 * 商品类
 */
public class Product {
    private String productId; // 商品ID
    private String productName; // 商品名称
    private Set<String> tags; // 商品标签（LinkedHashSet：去重+插入顺序）
    // 构造函数
    public Product(String productId, String productName) {
        this.productId = productId;
        this.productName = productName;
        this.tags = new LinkedHashSet<>();
    }
    // 添加标签（去重）
    public boolean addTag(String tag) {
        if (tag == null || tag.trim().isEmpty()) {
            throw new IllegalArgumentException("标签不能为空");
        }
        return tags.add(tag.trim());
    }
    // 批量添加标签
    public boolean addTags(Set<String> tags) {
        boolean success = false;
        for (String tag : tags) {
            if (addTag(tag)) {
                success = true;
            }
        }
        return success;
    }
    // 删除标签
    public boolean removeTag(String tag) {
        if (tag == null || tag.trim().isEmpty()) {
            return false;
        }
        return tags.remove(tag.trim());
    }
    // 获取所有标签（返回不可修改集合，防止外部篡改）
    public Set<String> getTags() {
        return new LinkedHashSet<>(tags);
    }
    // getter/setter 省略
    @Override
    public String toString() {
        return "Product{productId='" + productId + "', productName='" + productName + "', tags=" + tags + "}";
    }
}

import java.util.*;
import java.util.stream.Collectors;
/**
 * 标签管理类
 */
public class TagManager {
    // 存储商品列表（key：商品ID，value：商品对象）
    private Map<String, Product> productMap = new HashMap<>();
    // 存储标签频次（key：标签，value：使用次数）
    private Map<String, Integer> tagFrequencyMap = new HashMap<>();
    /**
     * 添加商品
     */
    public void addProduct(Product product) {
        if (product == null || product.getProductId() == null) {
            throw new IllegalArgumentException("商品信息不能为空");
        }
        productMap.put(product.getProductId(), product);
        // 初始化商品标签的频次
        for (String tag : product.getTags()) {
            tagFrequencyMap.put(tag, tagFrequencyMap.getOrDefault(tag, 0) + 1);
        }
    }
    /**
     * 为商品添加标签
     */
    public boolean addTagToProduct(String productId, String tag) {
        Product product = productMap.get(productId);
        if (product == null) {
            throw new IllegalArgumentException("商品不存在：" + productId);
        }
        // 商品添加标签（去重）
        boolean success = product.addTag(tag);
        if (success) {
            // 更新标签频次
            tagFrequencyMap.put(tag, tagFrequencyMap.getOrDefault(tag, 0) + 1);
        }
        return success;
    }
    /**
     * 为商品删除标签
     */
    public boolean removeTagFromProduct(String productId, String tag) {
        Product product = productMap.get(productId);
        if (product == null) {
            throw new IllegalArgumentException("商品不存在：" + productId);
        }
        // 商品删除标签
        boolean success = product.removeTag(tag);
        if (success) {
            // 更新标签频次
            int frequency = tagFrequencyMap.getOrDefault(tag, 0);
            if (frequency == 1) {
                tagFrequencyMap.remove(tag);
            } else {
                tagFrequencyMap.put(tag, frequency - 1);
            }
        }
        return success;
    }
    /**
     * 查询包含指定标签的所有商品
     */
    public List<Product> queryProductsByTag(String tag) {
        if (tag == null || tag.trim().isEmpty()) {
            return Collections.emptyList();
        }
        tag = tag.trim();
        // 遍历所有商品，筛选包含该标签的商品
        return productMap.values().stream()
                .filter(product -> product.getTags().contains(tag))
                .collect(Collectors.toList());
    }
    /**
     * 统计标签使用频次（按频次降序排序）
     */
    public Set<Map.Entry<String, Integer>> statTagFrequency() {
        // 使用 TreeSet 按频次降序排序，频次相同按标签字典序升序
        Set<Map.Entry<String, Integer>> sortedSet = new TreeSet<>((e1, e2) -> {
            if (!e1.getValue().equals(e2.getValue())) {
                return e2.getValue() - e1.getValue(); // 频次降序
            }
            return e1.getKey().compareTo(e2.getKey()); // 标签升序
        });
        sortedSet.addAll(tagFrequencyMap.entrySet());
        return sortedSet;
    }
    /**
     * 批量导入商品标签（自动去重）
     */
    public void batchImportTags(String productId, List<String> tags) {
        Product product = productMap.get(productId);
        if (product == null) {
            throw new IllegalArgumentException("商品不存在：" + productId);
        }
        // 批量添加标签（LinkedHashSet 自动去重）
        Set<String> tagSet = new LinkedHashSet<>(tags);
        product.addTags(tagSet);
        // 更新标签频次
        for (String tag : tagSet) {
            tagFrequencyMap.put(tag, tagFrequencyMap.getOrDefault(tag, 0) + 1);
        }
    }
    /**
     * 获取所有商品
     */
    public List<Product> getAllProducts() {
        return new ArrayList<>(productMap.values());
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.Map;
/**
 * 标签管理系统测试类
 */
public class TagManagerTest {
    public static void main(String[] args) {
        TagManager tagManager = new TagManager();
        // 1. 创建商品并添加到系统
        System.out.println("=== 1. 创建商品并添加标签 ===");
        Product p1 = new Product("P001", "Java编程思想");
        p1.addTag("编程");
        p1.addTag("Java");
        p1.addTag("书籍");
        p1.addTag("Java"); // 重复标签，自动去重
        tagManager.addProduct(p1);
        Product p2 = new Product("P002", "Python数据分析");
        p2.addTags(new LinkedHashSet<>(Arrays.asList("编程", "Python", "数据分析", "书籍")));
        tagManager.addProduct(p2);
        Product p3 = new Product("P003", "MySQL从入门到精通");
        p3.addTags(new LinkedHashSet<>(Arrays.asList("数据库", "MySQL", "编程", "书籍")));
        tagManager.addProduct(p3);
        // 查看所有商品
        System.out.println("所有商品信息：");
        tagManager.getAllProducts().forEach(System.out::println);
        System.out.println();
        // 2. 为商品添加新标签
        System.out.println("=== 2. 为商品 P001 添加标签 '技术' ===");
        boolean addSuccess = tagManager.addTagToProduct("P001", "技术");
        System.out.println("添加结果：" + (addSuccess ? "成功" : "失败（标签已存在）"));
        System.out.println("P001 最新标签：" + tagManager.getAllProducts().get(0).getTags());
        System.out.println();
        // 3. 为商品删除标签
        System.out.println("=== 3. 为商品 P002 删除标签 '数据分析' ===");
        boolean removeSuccess = tagManager.removeTagFromProduct("P002", "数据分析");
        System.out.println("删除结果：" + (removeSuccess ? "成功" : "失败（标签不存在）"));
        System.out.println("P002 最新标签：" + tagManager.getAllProducts().get(1).getTags());
        System.out.println();
        // 4. 查询包含标签 '编程' 的所有商品
        System.out.println("=== 4. 查询包含标签 '编程' 的商品 ===");
        List<Product> programmingProducts = tagManager.queryProductsByTag("编程");
        programmingProducts.forEach(System.out::println);
        System.out.println();
        // 5. 批量导入商品标签
        System.out.println("=== 5. 为商品 P003 批量导入标签 ===");
        List<String> batchTags = Arrays.asList("技术", "数据库", "后端", "后端"); // 重复标签自动去重
        tagManager.batchImportTags("P003", batchTags);
        System.out.println("P003 批量导入后的标签：" + tagManager.getAllProducts().get(2).getTags());
        System.out.println();
        // 6. 统计标签使用频次
        System.out.println("=== 6. 标签使用频次统计（降序） ===");
        Set<Map.Entry<String, Integer>> tagFrequency = tagManager.statTagFrequency();
        for (Map.Entry<String, Integer> entry : tagFrequency) {
            System.out.printf("标签：%s，使用次数：%d%n", entry.getKey(), entry.getValue());
        }
    }
}