Java集合框架实战：HashMap与HashSet的妙用

在Java编程中，集合框架是我们处理数据的利器。今天我们将通过两个实用的案例------单词统计器和数据去重排序器，来深入探索HashMap和HashSet的强大功能。

案例一：单词统计器 - HashMap的完美应用

项目概述

单词统计器是一个能够分析文本中单词出现频率的工具，在自然语言处理、文本分析和数据挖掘等领域有着广泛的应用。通过这个案例，我们将学习如何使用HashMap来高效地统计和管理键值对数据。

核心实现原理

java 复制代码

public class WordCounter {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("请输入一段文本:");
        String text = scanner.nextLine();
        
        // 使用HashMap统计单词出现次数
        HashMap<String, Integer> wordCount = new HashMap<>();
        
        // 分割文本为单词（按空格和标点符号分割）
        String[] words = text.split("[\\s\\p{Punct}]+");
        
        for (String word : words) {
            if (!word.isEmpty()) {
                String lowerWord = word.toLowerCase(); // 不区分大小写
                wordCount.put(lowerWord, wordCount.getOrDefault(lowerWord, 0) + 1);
            }
        }
        
        // 输出统计结果
        System.out.println("\n单词统计结果:");
        for (Map.Entry<String, Integer> entry : wordCount.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

技术深度解析

1. 文本分割策略

java 复制代码

String[] words = text.split("[\\s\\p{Punct}]+");

正则表达式详解：

\\s：匹配任何空白字符（空格、制表符、换行符等）

\\p{Punct}：匹配任何标点符号

+：表示一个或多个前述字符
这种分割方式能够处理各种复杂的文本情况，比如：

"hello,world!" → ["hello", "world"]

"data;analysis:important" → ["data", "analysis", "important"]

2. HashMap的智能更新

java 复制代码

wordCount.put(lowerWord, wordCount.getOrDefault(lowerWord, 0) + 1);

getOrDefault()方法的优势：

避免繁琐的null检查
代码更加简洁优雅
提高代码可读性

传统方式对比：

java 复制代码

// 传统方式
if (wordCount.containsKey(lowerWord)) {
    wordCount.put(lowerWord, wordCount.get(lowerWord) + 1);
} else {
    wordCount.put(lowerWord, 1);
}

// 现代方式（推荐）
wordCount.put(lowerWord, wordCount.getOrDefault(lowerWord, 0) + 1);

3. 大小写处理

通过toLowerCase()方法实现大小写不敏感的统计，确保"Hello"和"hello"被识别为同一个单词。

运行示例

请输入一段文本:

Hello world! Hello Java. Java is great, world is beautiful.

单词统计结果:

hello: 2

world: 2

java: 2

is: 2

great: 1

beautiful: 1

性能优化建议

1.初始容量设置：如果知道大致单词数量，可以设置初始容量提高性能

java 复制代码

HashMap<String, Integer> wordCount = new HashMap<>(expectedSize);

2.并行处理：对于大文本，可以使用并行流加速处理

java 复制代码

Arrays.stream(words)
      .parallel()
      .forEach(word -> {
          // 统计逻辑
      });

案例二：数据去重与排序 - HashSet与TreeSet的协同作战

项目概述

数据去重和排序是数据处理中的常见需求。这个案例展示了如何使用HashSet快速去重，并结合TreeSet或Collections.sort()实现排序功能。

完整实现代码

java 复制代码

public class DeduplicationAndSorting {
    public static void main(String[] args) {
        // 创建包含重复元素的整数列表
        ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(
            5, 2, 8, 2, 1, 9, 5, 3, 7, 1, 4, 6, 8, 3
        ));
        
        System.out.println("原始列表: " + numbers);
        
        // 使用HashSet去重
        HashSet<Integer> uniqueNumbers = new HashSet<>(numbers);
        System.out.println("去重后: " + uniqueNumbers);
        
        // 使用TreeSet排序（自动排序）
        TreeSet<Integer> sortedNumbers = new TreeSet<>(uniqueNumbers);
        System.out.println("排序后: " + sortedNumbers);
        
        // 或者使用Collections.sort()方法
        ArrayList<Integer> sortedList = new ArrayList<>(uniqueNumbers);
        Collections.sort(sortedList);
        System.out.println("使用Collections.sort()排序: " + sortedList);
    }
}

技术深度解析

1. HashSet去重机制

HashSet的工作原理：

基于HashMap实现
利用哈希表快速查找
自动处理重复元素
去重效率分析：
时间复杂度：O(n)
空间复杂度：O(n)
比手动去重（O(n²)）高效得多

2. 两种排序方式对比

方式一：TreeSet自动排序
TreeSet<Integer> sortedNumbers = new TreeSet<>(uniqueNumbers);
特点：

自动维护元素顺序
基于红黑树实现
插入时即排序，查询效率高
方式二：Collections.sort()
ArrayList<Integer> sortedList = new ArrayList<>(uniqueNumbers); Collections.sort(sortedList);
特点：
对现有集合进行排序
基于TimSort算法
更灵活，可自定义比较器

运行结果展示

原始列表: [5, 2, 8, 2, 1, 9, 5, 3, 7, 1, 4, 6, 8, 3]
去重后: [1, 2, 3, 4, 5, 6, 7, 8, 9]
排序后: [1, 2, 3, 4, 5, 6, 7, 8, 9]
使用Collections.sort()排序: [1, 2, 3, 4, 5, 6, 7, 8, 9]

高级特性扩展

1. 自定义对象去重

对于自定义对象，需要重写equals()和hashCode()方法：

java 复制代码

class Student {
    private String id;
    private String name;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

2. 自定义排序规则

java 复制代码

// 降序排序
TreeSet<Integer> descendingSet = new TreeSet<>(Collections.reverseOrder());
descendingSet.addAll(uniqueNumbers);

// 自定义对象排序
TreeSet<Student> studentSet = new TreeSet<>(
    Comparator.comparing(Student::getName)
              .thenComparing(Student::getAge)
);

集合框架选择指南

根据需求选择合适的集合

|--------|-----------------------------------------------|-----------|
| 需求 | 推荐集合 | 理由 |
| 快速查找 | HashMap/HashSet | O(1)时间复杂度 |
| 保持插入顺序 | LinkedHashMap/LinkedHashSet | 维护插入顺序 |
| 自动排序 | TreeMap/TreeSet | 红黑树实现自动排序 |
| 线程安全 | ConcurrentHashMap/Collections.synchronizedSet | 多线程环境使用 |

性能对比分析

|----|------------|---------|----------|
| 操作 | ArrayList | HashSet | TreeSet |
| 添加 | O(1) | O(1) | O(log n) |
| 查找 | O(n) | O(1) | O(log n) |
| 删除 | O(n) | O(1) | O(log n) |
| 排序 | O(n log n) | 不支持 | 自动排序 |

实际应用场景

单词统计器的应用

搜索引擎：关键词频率分析
社交媒体：热点话题挖掘
学术研究：文献关键词分析
商业智能：客户反馈分析

数据去重排序的应用

数据分析：数据清洗和预处理
数据库操作：结果集去重
推荐系统：用户兴趣标签处理
缓存系统：唯一标识管理

最佳实践总结

选择合适的初始容量：避免频繁扩容
重写hashCode和equals：确保自定义对象正确工作
使用泛型：提高类型安全性
考虑线程安全：多线程环境使用并发集合
利用Java 8+特性：Stream API和Lambda表达式简化代码
通过这两个实战案例，我们不仅掌握了HashMap和HashSet的基本用法，还深入理解了它们在不同场景下的应用技巧。这些知识将为你在实际开发中处理复杂数据问题提供有力的工具和支持。