Collections 工具类详解

import java.util.*;

/**
 * 场景：月初，大翔要求对飞翔科技各部门提交的薪资报表进行排序和统计。
 * 白歌使用 Collections 工具类完成排序、查找、反转和频率统计。
 * Frank 要求报表能按部门索引快速定位特定工资。
 */
public class FeiXiangSalaryReport {

    /** 员工工资条目 */
    static class SalaryEntry implements Comparable<SalaryEntry> {
        final String name;
        final String department;
        final double salary;

        SalaryEntry(String name, String department, double salary) {
            this.name = name;
            this.department = department;
            this.salary = salary;
        }

        // 自然排序：按工资升序（Comparable）
        @Override
        public int compareTo(SalaryEntry o) {
            return Double.compare(this.salary, o.salary);
        }

        @Override
        public String toString() {
            return String.format("%s(%s, ¥%.0f)", name, department, salary);
        }
    }

    public static void main(String[] args) {
        // ========== 1. 原始工资数据 ==========
        List<SalaryEntry> salaries = new ArrayList<>(Arrays.asList(
            new SalaryEntry("大翔", "管理层", 80000),
            new SalaryEntry("白歌", "技术部", 35000),
            new SalaryEntry("小崔", "技术部", 12000),
            new SalaryEntry("孔蓝", "测试部", 15000),
            new SalaryEntry("Frank", "市场部", 22000),
            new SalaryEntry("黄俪", "人事部", 18000),
            new SalaryEntry("赵鸣", "技术部", 35000),
            new SalaryEntry("孙鹤", "技术部", 12000)
        ));

        System.out.println("=== 飞翔科技月度工资报表 ===\n");
        System.out.println("原始数据: " + salaries.size() + " 条记录");

        // ========== 2. sort：按自然顺序（升序） ==========
        Collections.sort(salaries);
        System.out.println("\n--- 按工资升序（自然排序） ---");
        salaries.forEach(s -> System.out.println("  " + s));

        // ========== 3. sort + reverseOrder：降序 ==========
        Collections.sort(salaries, Collections.reverseOrder());
        System.out.println("\n--- 按工资降序 ---");
        salaries.forEach(s -> System.out.println("  " + s));

        // 恢复升序以便后续操作
        Collections.sort(salaries);

        // ========== 4. binarySearch：二分查找 ==========
        System.out.println("\n--- 二分查找（List 已按升序排列） ---");
        SalaryEntry target = new SalaryEntry("", "", 22000);
        int idx = Collections.binarySearch(salaries, target);
        System.out.println("查找 ¥22000: 索引 = " + idx + " → " + salaries.get(idx));

        // 查找不存在的工资
        int idx2 = Collections.binarySearch(salaries, new SalaryEntry("", "", 20000));
        System.out.println("查找 ¥20000: 索引 = " + idx2
            + " (不存在, 应插入位置: " + (-(idx2 + 1)) + ")");

        // ========== 5. min / max ==========
        SalaryEntry minSalary = Collections.min(salaries);
        SalaryEntry maxSalary = Collections.max(salaries);
        System.out.println("\n--- 极值 ---");
        System.out.println("最低工资: " + minSalary);
        System.out.println("最高工资: " + maxSalary);

        // ========== 6. frequency：频率统计 ==========
        SalaryEntry query = new SalaryEntry("", "", 12000);
        int freq = Collections.frequency(salaries, query);
        System.out.println("\n--- 频率统计 ---");
        System.out.println("工资恰好为 ¥12000 的人数: " + freq);

        // ========== 7. reverse：反转 ==========
        System.out.println("\n--- 反转列表 ---");
        Collections.reverse(salaries);
        System.out.println("反转后前三: " + salaries.subList(0, 3));

        // 恢复升序
        Collections.sort(salaries);

        // ========== 8. shuffle + rotate ==========
        System.out.println("\n--- 随机打乱 + 循环移动 ---");
        // 使用固定种子确保演示可复现
        Collections.shuffle(salaries, new Random(42));
        System.out.println("打乱后: " + salaries.subList(0, 5) + "...");

        Collections.rotate(salaries, 3);  // 右移 3 位
        System.out.println("右移3位后: " + salaries.subList(0, 5) + "...");

        // ========== 9. 按部门排序（自定义 Comparator） ==========
        System.out.println("\n--- 按部门 + 姓名排序 ---");
        Collections.sort(salaries, Comparator
            .comparing((SalaryEntry s) -> s.department)
            .thenComparing(s -> s.name));
        salaries.forEach(s -> System.out.println("  " + s));
    }
}

import java.util.*;

/**
 * 场景：飞翔科技的共享配置数据被多个线程同时访问。
 * 白歌要求小崔对配置列表进行线程安全改造，并对只读配置进行不可变保护。
 * 孔蓝负责验证线程安全性和不可变性的边界情况。
 */
public class FeiXiangCollectionsWrapper {

    /** 模拟飞翔科技的在线用户列表（多线程共享） */
    static class OnlineUserTracker {
        // 线程安全的 List
        private final List<String> onlineUsers;

        public OnlineUserTracker() {
            // synchronizedList 包装普通的 ArrayList
            this.onlineUsers = Collections.synchronizedList(new ArrayList<>());
        }

        /** 用户上线 */
        public void login(String username) {
            onlineUsers.add(username);
        }

        /** 用户下线 */
        public void logout(String username) {
            onlineUsers.remove(username);
        }

        /** 获取在线用户快照（安全遍历） */
        public List<String> getOnlineUserSnapshot() {
            // 遍历时必须手动加锁！
            synchronized (onlineUsers) {
                return new ArrayList<>(onlineUsers);  // 返回副本
            }
        }

        /** 获取在线人数 */
        public int getOnlineCount() {
            return onlineUsers.size();
        }
    }

    /** 飞翔科技的系统配置（只读） */
    static class SystemConfig {
        private final List<String> adminNames;
        private final Map<String, String> settings;

        public SystemConfig() {
            // 内部使用可变的集合
            List<String> admins = new ArrayList<>();
            admins.add("大翔");
            admins.add("白歌");

            Map<String, String> configs = new HashMap<>();
            configs.put("company", "飞翔科技");
            configs.put("version", "2.0.0");
            configs.put("maxLoginAttempts", "5");

            // 暴露不可变视图
            this.adminNames = Collections.unmodifiableList(admins);
            this.settings = Collections.unmodifiableMap(configs);
        }

        public List<String> getAdminNames() { return adminNames; }
        public Map<String, String> getSettings() { return settings; }
    }

    public static void main(String[] args) {
        // ========== 一、线程安全包装 ==========
        System.out.println("=== 线程安全包装演示 ===");

        OnlineUserTracker tracker = new OnlineUserTracker();

        // 模拟多用户上线
        tracker.login("大翔");
        tracker.login("白歌");
        tracker.login("小崔");
        tracker.login("孔蓝");

        System.out.println("当前在线: " + tracker.getOnlineUserSnapshot());
        System.out.println("在线人数: " + tracker.getOnlineCount());

        tracker.logout("小崔");
        System.out.println("小崔下线后: " + tracker.getOnlineUserSnapshot());

        // 验证线程安全：多线程同时操作
        System.out.println("\n--- 多线程并发登录测试 ---");
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                tracker.login("用户A-" + i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                tracker.login("用户B-" + i);
            }
        });
        t1.start(); t2.start();
        try { t1.join(); t2.join(); } catch (InterruptedException e) {}
        System.out.println("并发操作后在线人数: " + tracker.getOnlineCount()
            + " (期望: " + (4 - 1 + 200) + ")");

        // ========== 二、不可变包装 ==========
        System.out.println("\n=== 不可变包装演示 ===");

        SystemConfig config = new SystemConfig();
        System.out.println("管理员列表: " + config.getAdminNames());
        System.out.println("系统配置: " + config.getSettings());

        // 尝试修改不可变列表
        try {
            config.getAdminNames().add("Frank");  // 应该抛异常
        } catch (UnsupportedOperationException e) {
            System.out.println("修改被拦截: " + e.getClass().getSimpleName()
                + " —— 不可变集合不允许修改");
        }

        // 读取依然正常
        System.out.println("管理员列表（仍为只读）: " + config.getAdminNames());

        // ========== 三、特殊集合 ==========
        System.out.println("\n=== 特殊集合 ===");

        // 空集合（共享单例）
        List<String> emptyList = Collections.emptyList();
        System.out.println("空列表: " + emptyList + " (isEmpty: " + emptyList.isEmpty() + ")");

        // 单元素集合（不可变）
        Set<String> ceo = Collections.singleton("大翔-CEO");
        System.out.println("CEO 集合: " + ceo);

        // nCopies
        List<String> pendingStatus = Collections.nCopies(5, "待审批");
        System.out.println("5 个待审批: " + pendingStatus);

        // ========== 四、Comparator 工具方法 ==========
        System.out.println("\n=== Comparator 工具 ===");

        List<String> names = new ArrayList<>(Arrays.asList(
            "白歌", "小崔", "大翔", "孔蓝", "Frank"
        ));

        // 自然顺序的逆序
        Collections.sort(names, Collections.reverseOrder());
        System.out.println("逆字典序: " + names);

        // 恢复自然顺序
        Collections.sort(names);
        System.out.println("自然字典序: " + names);

        // ========== 五、disjoint：判断无交集 ==========
        System.out.println("\n=== 集合运算 ===");
        Set<String> techDept = new HashSet<>(Arrays.asList("白歌", "小崔", "赵鸣", "孙鹤"));
        Set<String> mgmtDept = new HashSet<>(Arrays.asList("大翔", "Frank"));
        Set<String> allDept = new HashSet<>(Arrays.asList("白歌", "小崔", "大翔", "Frank", "孔蓝"));

        System.out.println("技术部与管理层无交集？ "
            + Collections.disjoint(techDept, mgmtDept));  // true

        System.out.println("技术部与全员有交集？ "
            + Collections.disjoint(techDept, allDept));   // false
    }
}

// ❌ 错误：未排序的 list 上调用 binarySearch，结果不可预测
List<Integer> list = Arrays.asList(5, 2, 8, 1, 3);
int idx = Collections.binarySearch(list, 2);
System.out.println(idx);  // 可能是任何值（正数/负数），完全不可靠！

// ✅ 正确：先排序再二分查找
Collections.sort(list);  // [1, 2, 3, 5, 8]
int idx = Collections.binarySearch(list, 2);  // 1，正确

// ❌ 错误：遍历 synchronizedList 时未手动同步
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
syncList.add("大翔"); syncList.add("白歌"); syncList.add("小崔");

// 线程1：用 for-each 遍历（内部使用迭代器）
new Thread(() -> {
    for (String s : syncList) {
        System.out.println(s);  // 可能抛 ConcurrentModificationException
        try { Thread.sleep(100); } catch (InterruptedException e) {}
    }
}).start();

// 线程2：添加
new Thread(() -> {
    syncList.add("孔蓝");  // 虽然 add 是同步的，但无法保护整个迭代过程
}).start();

// ✅ 正确：遍历时手动加锁
synchronized (syncList) {  // 锁住整个遍历过程
    for (String s : syncList) {
        System.out.println(s);
    }
}

// ✅ 或使用迭代器 + 手动加锁
synchronized (syncList) {
    Iterator<String> it = syncList.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
}

// ❌ 误区：以为 unmodifiableList 连元素状态都保护了
class MutableEmployee {
    String name;
    MutableEmployee(String name) { this.name = name; }
    void setName(String name) { this.name = name; }
    @Override
    public String toString() { return name; }
}

List<MutableEmployee> list = new ArrayList<>();
list.add(new MutableEmployee("小崔"));
list.add(new MutableEmployee("白歌"));

List<MutableEmployee> unmodList = Collections.unmodifiableList(list);

// 不能修改 List 结构（抛异常）
// unmodList.add(new MutableEmployee("孔蓝"));  // ✗ UnsupportedOperationException

// 但可以修改元素内部状态！
unmodList.get(0).setName("小崔（已修改）");  // ✓ 成功了！
System.out.println(unmodList);  // [小崔（已修改）, 白歌]

// ✅ 如需深度不可变，元素类也应该是不可变的
class ImmutableEmployee {
    private final String name;
    public ImmutableEmployee(String name) { this.name = name; }
    public String getName() { return name; }
    // 无 setter 方法 —— 完全不可变
}

// ✅ 或使用 Guava 的 ImmutableList.copyOf（深拷贝）
// ImmutableList<Employee> immutable = ImmutableList.copyOf(original);

// ❌ 错误：copy 要求目标列表长度 >= 源列表长度
List<String> src = Arrays.asList("A", "B", "C", "D");
List<String> dest = new ArrayList<>(2);  // 长度不够！
Collections.copy(dest, src);  // IndexOutOfBoundsException！

// ✅ 方案一：预先填充够长度的元素
List<String> dest = new ArrayList<>(Collections.nCopies(src.size(), ""));
Collections.copy(dest, src);  // OK

// ✅ 方案二：直接用构造器（推荐）
List<String> dest = new ArrayList<>(src);  // 更简单直接