哪些Java案例能展示集合框架用法？

本文目录导读：

1. 榜单&投票（List + 排序）
2. 日活用户去重（Set）
3. 热点词频统计（HashMap + 遍历）
4. 双端队列（Deque）实现回文检查
5. 优先级队列（PriorityQueue）实现任务调度
6. Stream API 结合集合操作（现代写法）

Java集合框架是日常开发中最常用的工具之一,掌握它的核心用法（如List、Set、Map及其常用实现类）非常重要，下面提供几个典型的Java案例，涵盖增删改查、遍历、排序、去重、线程安全等常见场景。

榜单&投票（List + 排序）

场景：实现一个简单的投票统计，按票数从高到低排序，取前3名。

import java.util.*;
public class VoteRanking {
    public static void main(String[] args) {
        // 模拟投票数据：候选人 -> 票数
        Map<String, Integer> voteMap = new HashMap<>();
        voteMap.put("张三", 120);
        voteMap.put("李四", 350);
        voteMap.put("王五", 98);
        voteMap.put("赵六", 210);
        voteMap.put("孙七", 450);
        // 将Map的Entry放入List，按value（票数）降序排序
        List<Map.Entry<String, Integer>> list = new ArrayList<>(voteMap.entrySet());
        list.sort((e1, e2) -> e2.getValue().compareTo(e1.getValue()));
        // 输出前三名
        System.out.println("=== 投票排名 TOP3 ===");
        for (int i = 0; i < Math.min(3, list.size()); i++) {
            Map.Entry<String, Integer> entry = list.get(i);
            System.out.println("第" + (i + 1) + "名：" + entry.getKey() + "（" + entry.getValue() + "票）");
        }
    }
}

知识点：

• HashMap：存储键值对（无序）
• ArrayList：将Map.Entry转为List，方便排序
• sort() + Lambda：自定义排序规则

日活用户去重（Set）

场景：统计当天活跃的用户ID，去除重复登录的用户。

import java.util.*;
public class DailyActiveUsers {
    public static void main(String[] args) {
        // 模拟某天所有用户的登录记录（可能含重复）
        List<String> loginRecords = Arrays.asList(
            "user001", "user002", "user003", 
            "user001", "user004", "user002", "user005"
        );
        // 使用HashSet自动去重
        Set<String> activeUsers = new HashSet<>(loginRecords);
        System.out.println("全部登录记录：\n" + loginRecords);
        System.out.println("\n去重后的活跃用户（共计" + activeUsers.size() + "人）：");
        // 使用增强for循环遍历Set
        for (String user : activeUsers) {
            System.out.println(" - " + user);
        }
        // 验证是否包含某个用户
        System.out.println("\nuser001是否活跃：" + activeUsers.contains("user001"));
    }
}

知识点：

• HashSet：无序、唯一、适合去重
• Set.contains()：快速查找

热点词频统计（HashMap + 遍历）

场景：统计文章里每个单词出现的次数，并按频率降序输出。

import java.util.*;
public class WordCount {
    public static void main(String[] args) {
        String text = "apple banana apple orange banana apple grape";
        String[] words = text.split(" ");
        Map<String, Integer> freqMap = new HashMap<>();
        for (String word : words) {
            // getOrDefault避免空指针，简洁优雅
            freqMap.put(word, freqMap.getOrDefault(word, 0) + 1);
        }
        // 按词频降序排序输出
        List<Map.Entry<String, Integer>> list = new ArrayList<>(freqMap.entrySet());
        list.sort((e1, e2) -> e2.getValue().compareTo(e1.getValue()));
        System.out.println("=== 词频统计（降序）===");
        for (Map.Entry<String, Integer> entry : list) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

知识点：

• HashMap：计数神器
• getOrDefault：避免手动判空
• Entry排序输出

双端队列（Deque）实现回文检查

场景：判断一个字符串是否是回文（正反读相同），利用双端队列高效实现。

import java.util.*;
public class PalindromeCheck {
    public static boolean isPalindrome(String s) {
        // 转小写并去除非字母数字字符
        String cleaned = s.toLowerCase().replaceAll("[^a-z0-9]", "");
        // 双端队列: ArrayDeque
        Deque<Character> deque = new ArrayDeque<>();
        for (char c : cleaned.toCharArray()) {
            deque.addLast(c);
        }
        // 两端同时取出比较
        while (deque.size() > 1) {
            if (!deque.removeFirst().equals(deque.removeLast())) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        String test1 = "A man, a plan, a canal: Panama";
        String test2 = "race a car";
        System.out.println("\"" + test1 + "\" 是否为回文？ " + isPalindrome(test1));
        System.out.println("\"" + test2 + "\" 是否为回文？ " + isPalindrome(test2));
    }
}

知识点：

• Deque（双端队列）vs LinkedList：ArrayDeque 性能更好，适合栈/队列场景
• removeFirst() / removeLast()：从两端操作

优先级队列（PriorityQueue）实现任务调度

场景：模拟一个简单的任务调度系统，按紧急程度（优先级）取出任务执行。

import java.util.*;
class Task {
    String name;
    int priority; // 数字越小越紧急
    Task(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }
    @Override
    public String toString() {
        return name + "（优先级" + priority + "）";
    }
}
public class TaskScheduler {
    public static void main(String[] args) {
        // 小顶堆：优先级数字越小越靠前
        PriorityQueue<Task> queue = new PriorityQueue<>(
            (t1, t2) -> Integer.compare(t1.priority, t2.priority)
        );
        // 插入任务
        queue.offer(new Task("系统更新", 5));
        queue.offer(new Task("安全补丁", 1));
        queue.offer(new Task("用户反馈处理", 3));
        queue.offer(new Task("日志清理", 10));
        System.out.println("=== 任务执行顺序（按优先级）===");
        while (!queue.isEmpty()) {
            System.out.println("执行中：" + queue.poll());
        }
    }
}

知识点：

• PriorityQueue：天然堆结构，适合优先级队列
• 自定义比较器决定“紧急”顺序

Stream API 结合集合操作（现代写法）

场景：筛选出所有分数高于90的学生，并按分数降序取前3名。

import java.util.*;
import java.util.stream.Collectors;
class Student {
    String name;
    int score;
    Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    public String toString() {
        return name + ":" + score;
    }
}
public class StreamExample {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("小明", 92),
            new Student("小红", 88),
            new Student("小刚", 95),
            new Student("小美", 78),
            new Student("小强", 91)
        );
        // 链式操作：筛选 -> 排序 -> 取前3 -> 收集成List
        List<Student> top3 = students.stream()
            .filter(s -> s.score > 90)
            .sorted((a, b) -> b.score - a.score)  // 降序
            .limit(3)
            .collect(Collectors.toList());
        System.out.println("分数 > 90 的前三名：");
        top3.forEach(System.out::println);
        // 也可以直接输出姓名列表
        List<String> names = top3.stream()
            .map(s -> s.name)
            .collect(Collectors.toList());
        System.out.println("姓名列表：" + names);
    }
}

知识点：

• Stream API：filter、sorted、limit、collect
• map 提取属性、forEach 遍历
• 函数式编程风格简化集合处理

这些案例涵盖了日常开发中最常用的集合操作,建议在实际编码时多动手敲一遍，对理解集合框架的“增删改查+排序+去重+遍历”会很有帮助。