// 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 {
    // 底層存儲(chǔ)核心：HashMap 對(duì)象
    private transient HashMap<E, Object> map;
    // 固定的 value 對(duì)象，所有 key 都映射到該對(duì)象
    private static final Object PRESENT = new Object();
    // 無(wú)參構(gòu)造：創(chuàng)建空的 HashMap
    public HashSet() {
        map = new HashMap<>();
    }
    // 指定初始容量的構(gòu)造函數(shù)
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
    // 指定初始容量和負(fù)載因子的構(gòu)造函數(shù)
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
}

public boolean add(E e) {
    // 調(diào)用 HashMap 的 put 方法，key 為待添加元素，value 為 PRESENT
    // HashMap 的 put 方法返回 null 表示添加成功（key 不存在），返回舊 value 表示添加失?。╧ey 已存在）
    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;
    // 僅重寫(xiě) equals()，未重寫(xiě) 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);
    }
    // 省略構(gòu)造函數(shù)和 getter/setter
}
// 測(cè)試：兩個(gè) equals() 相同但 hashCode() 不同的對(duì)象
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 類(lèi)的 hashCode() 基于對(duì)象地址）
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;
    // 構(gòu)造函數(shù)、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() 依賴(lài)的屬性計(jì)算哈希值
        return Objects.hash(name, age);
    }
}
// 測(cè)試：去重生效
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 個(gè)，指定初始容量 1334
HashSet<String> set = new HashSet<>(1334);

public class LinkedHashSet<E> extends HashSet<E>
        implements Set<E>, Cloneable, java.io.Serializable {
    // 構(gòu)造函數(shù)：調(diào)用父類(lèi) HashSet 的構(gòu)造函數(shù)，創(chuàng)建 LinkedHashMap 實(shí)例
    public LinkedHashSet() {
        super(16, .75f, true);
    }
    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }
    // 父類(lèi) HashSet 中對(duì)應(yīng)的構(gòu)造函數(shù)（包訪問(wèn)權(quán)限）
    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; // 雙向鏈表的前驅(qū)和后繼指針
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

// 自定義訪問(wèn)順序的 LinkedHashSet
class AccessOrderLinkedHashSet<E> extends LinkedHashSet<E> {
    public AccessOrderLinkedHashSet(int initialCapacity, float loadFactor) {
        super(new LinkedHashMap<>(initialCapacity, loadFactor, true));
    }
}
// 測(cè)試訪問(wèn)順序
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"); // 訪問(wèn) B 元素
        System.out.println("訪問(wèn) B 后遍歷：" + new ArrayList<>(set)); // [A, C, B]（B 移到尾部）
    }
}

public class TreeSet<E> extends AbstractSet<E>
        implements NavigableSet<E>, Cloneable, java.io.Serializable {
    // 底層存儲(chǔ)核心：TreeMap 對(duì)象
    private transient NavigableMap<E, Object> m;
    // 固定的 value 對(duì)象，與 HashSet 類(lèi)似
    private static final Object PRESENT = new Object();
    // 構(gòu)造函數(shù)：創(chuàng)建 TreeMap 實(shí)例
    public TreeSet() {
        this(new TreeMap<>());
    }
    // 自定義比較器的構(gòu)造函數(shù)
    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;
    // 構(gòu)造函數(shù)、getter/setter 省略
    // 按分?jǐn)?shù)降序排序，分?jǐn)?shù)相同按學(xué)號(hào)升序排序
    @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 + "}";
    }
}
// 測(cè)試自然排序
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));
        // 遍歷：按分?jǐn)?shù)降序，分?jǐn)?shù)相同按學(xué)號(hào)升序
        for (Student s : set) {
            System.out.println(s);
        }
        // 輸出結(jié)果：
        // 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;
    // 構(gòu)造函數(shù)、getter/setter、toString 省略
}
// 測(cè)試定制排序（按年齡升序）
public class TreeSetCustomSortTest {
    public static void main(String[] args) {
        // 傳入 Comparator 匿名內(nèi)部類(lèi)（Java 8+ 可簡(jiǎn)化為 Lambda 表達(dá)式）
        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);
        }
        // 輸出結(jié)果：
        // Employee{name='李四', age=22}
        // Employee{name='張三', age=25}
        // Employee{name='王五', age=28}
    }
}

public boolean add(E e) {
    // 調(diào)用 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（高效去重，性能最優(yōu)）
Set<String> usernames = new HashSet<>();
usernames.add("zhangsan");
usernames.add("lisi");
// 重復(fù)添加會(huì)失敗
usernames.add("zhangsan");
System.out.println(usernames.size()); // 1

// 選型：LinkedHashSet（去重+插入順序）
Set<String> operationLogs = new LinkedHashSet<>();
operationLogs.add("用戶(hù)登錄");
operationLogs.add("查詢(xún)數(shù)據(jù)");
operationLogs.add("修改數(shù)據(jù)");
operationLogs.add("用戶(hù)退出");
// 遍歷順序與插入順序一致
for (String log : operationLogs) {
    System.out.println(log); // 用戶(hù)登錄 → 查詢(xún)數(shù)據(jù) → 修改數(shù)據(jù) → 用戶(hù)退出
}

// 選型：TreeSet（去重+排序+導(dǎo)航方法）
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 查詢(xún)（升序迭代器取前3個(gè)）
Iterator<Student> iterator = scoreRank.iterator();
int count = 0;
System.out.println("成績(jī)排行榜 Top3：");
while (iterator.hasNext() && count < 3) {
    System.out.println(++count + "：" + iterator.next());
}

import java.util.LinkedHashSet;
import java.util.Set;
/**
 * 商品類(lèi)
 */
public class Product {
    private String productId; // 商品ID
    private String productName; // 商品名稱(chēng)
    private Set<String> tags; // 商品標(biāo)簽（LinkedHashSet：去重+插入順序）
    // 構(gòu)造函數(shù)
    public Product(String productId, String productName) {
        this.productId = productId;
        this.productName = productName;
        this.tags = new LinkedHashSet<>();
    }
    // 添加標(biāo)簽（去重）
    public boolean addTag(String tag) {
        if (tag == null || tag.trim().isEmpty()) {
            throw new IllegalArgumentException("標(biāo)簽不能為空");
        }
        return tags.add(tag.trim());
    }
    // 批量添加標(biāo)簽
    public boolean addTags(Set<String> tags) {
        boolean success = false;
        for (String tag : tags) {
            if (addTag(tag)) {
                success = true;
            }
        }
        return success;
    }
    // 刪除標(biāo)簽
    public boolean removeTag(String tag) {
        if (tag == null || tag.trim().isEmpty()) {
            return false;
        }
        return tags.remove(tag.trim());
    }
    // 獲取所有標(biāo)簽（返回不可修改集合，防止外部篡改）
    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;
/**
 * 標(biāo)簽管理類(lèi)
 */
public class TagManager {
    // 存儲(chǔ)商品列表（key：商品ID，value：商品對(duì)象）
    private Map<String, Product> productMap = new HashMap<>();
    // 存儲(chǔ)標(biāo)簽頻次（key：標(biāo)簽，value：使用次數(shù)）
    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);
        // 初始化商品標(biāo)簽的頻次
        for (String tag : product.getTags()) {
            tagFrequencyMap.put(tag, tagFrequencyMap.getOrDefault(tag, 0) + 1);
        }
    }
    /**
     * 為商品添加標(biāo)簽
     */
    public boolean addTagToProduct(String productId, String tag) {
        Product product = productMap.get(productId);
        if (product == null) {
            throw new IllegalArgumentException("商品不存在：" + productId);
        }
        // 商品添加標(biāo)簽（去重）
        boolean success = product.addTag(tag);
        if (success) {
            // 更新標(biāo)簽頻次
            tagFrequencyMap.put(tag, tagFrequencyMap.getOrDefault(tag, 0) + 1);
        }
        return success;
    }
    /**
     * 為商品刪除標(biāo)簽
     */
    public boolean removeTagFromProduct(String productId, String tag) {
        Product product = productMap.get(productId);
        if (product == null) {
            throw new IllegalArgumentException("商品不存在：" + productId);
        }
        // 商品刪除標(biāo)簽
        boolean success = product.removeTag(tag);
        if (success) {
            // 更新標(biāo)簽頻次
            int frequency = tagFrequencyMap.getOrDefault(tag, 0);
            if (frequency == 1) {
                tagFrequencyMap.remove(tag);
            } else {
                tagFrequencyMap.put(tag, frequency - 1);
            }
        }
        return success;
    }
    /**
     * 查詢(xún)包含指定標(biāo)簽的所有商品
     */
    public List<Product> queryProductsByTag(String tag) {
        if (tag == null || tag.trim().isEmpty()) {
            return Collections.emptyList();
        }
        tag = tag.trim();
        // 遍歷所有商品，篩選包含該標(biāo)簽的商品
        return productMap.values().stream()
                .filter(product -> product.getTags().contains(tag))
                .collect(Collectors.toList());
    }
    /**
     * 統(tǒng)計(jì)標(biāo)簽使用頻次（按頻次降序排序）
     */
    public Set<Map.Entry<String, Integer>> statTagFrequency() {
        // 使用 TreeSet 按頻次降序排序，頻次相同按標(biāo)簽字典序升序
        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()); // 標(biāo)簽升序
        });
        sortedSet.addAll(tagFrequencyMap.entrySet());
        return sortedSet;
    }
    /**
     * 批量導(dǎo)入商品標(biāo)簽（自動(dòng)去重）
     */
    public void batchImportTags(String productId, List<String> tags) {
        Product product = productMap.get(productId);
        if (product == null) {
            throw new IllegalArgumentException("商品不存在：" + productId);
        }
        // 批量添加標(biāo)簽（LinkedHashSet 自動(dòng)去重）
        Set<String> tagSet = new LinkedHashSet<>(tags);
        product.addTags(tagSet);
        // 更新標(biāo)簽頻次
        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;
/**
 * 標(biāo)簽管理系統(tǒng)測(cè)試類(lèi)
 */
public class TagManagerTest {
    public static void main(String[] args) {
        TagManager tagManager = new TagManager();
        // 1. 創(chuàng)建商品并添加到系統(tǒng)
        System.out.println("=== 1. 創(chuàng)建商品并添加標(biāo)簽 ===");
        Product p1 = new Product("P001", "Java編程思想");
        p1.addTag("編程");
        p1.addTag("Java");
        p1.addTag("書(shū)籍");
        p1.addTag("Java"); // 重復(fù)標(biāo)簽，自動(dòng)去重
        tagManager.addProduct(p1);
        Product p2 = new Product("P002", "Python數(shù)據(jù)分析");
        p2.addTags(new LinkedHashSet<>(Arrays.asList("編程", "Python", "數(shù)據(jù)分析", "書(shū)籍")));
        tagManager.addProduct(p2);
        Product p3 = new Product("P003", "MySQL從入門(mén)到精通");
        p3.addTags(new LinkedHashSet<>(Arrays.asList("數(shù)據(jù)庫(kù)", "MySQL", "編程", "書(shū)籍")));
        tagManager.addProduct(p3);
        // 查看所有商品
        System.out.println("所有商品信息：");
        tagManager.getAllProducts().forEach(System.out::println);
        System.out.println();
        // 2. 為商品添加新標(biāo)簽
        System.out.println("=== 2. 為商品 P001 添加標(biāo)簽 '技術(shù)' ===");
        boolean addSuccess = tagManager.addTagToProduct("P001", "技術(shù)");
        System.out.println("添加結(jié)果：" + (addSuccess ? "成功" : "失?。?biāo)簽已存在）"));
        System.out.println("P001 最新標(biāo)簽：" + tagManager.getAllProducts().get(0).getTags());
        System.out.println();
        // 3. 為商品刪除標(biāo)簽
        System.out.println("=== 3. 為商品 P002 刪除標(biāo)簽 '數(shù)據(jù)分析' ===");
        boolean removeSuccess = tagManager.removeTagFromProduct("P002", "數(shù)據(jù)分析");
        System.out.println("刪除結(jié)果：" + (removeSuccess ? "成功" : "失敗（標(biāo)簽不存在）"));
        System.out.println("P002 最新標(biāo)簽：" + tagManager.getAllProducts().get(1).getTags());
        System.out.println();
        // 4. 查詢(xún)包含標(biāo)簽 '編程' 的所有商品
        System.out.println("=== 4. 查詢(xún)包含標(biāo)簽 '編程' 的商品 ===");
        List<Product> programmingProducts = tagManager.queryProductsByTag("編程");
        programmingProducts.forEach(System.out::println);
        System.out.println();
        // 5. 批量導(dǎo)入商品標(biāo)簽
        System.out.println("=== 5. 為商品 P003 批量導(dǎo)入標(biāo)簽 ===");
        List<String> batchTags = Arrays.asList("技術(shù)", "數(shù)據(jù)庫(kù)", "后端", "后端"); // 重復(fù)標(biāo)簽自動(dòng)去重
        tagManager.batchImportTags("P003", batchTags);
        System.out.println("P003 批量導(dǎo)入后的標(biāo)簽：" + tagManager.getAllProducts().get(2).getTags());
        System.out.println();
        // 6. 統(tǒng)計(jì)標(biāo)簽使用頻次
        System.out.println("=== 6. 標(biāo)簽使用頻次統(tǒng)計(jì)（降序） ===");
        Set<Map.Entry<String, Integer>> tagFrequency = tagManager.statTagFrequency();
        for (Map.Entry<String, Integer> entry : tagFrequency) {
            System.out.printf("標(biāo)簽：%s，使用次數(shù)：%d%n", entry.getKey(), entry.getValue());
        }
    }
}