本文目录导读：
Java HashMap 使用案例
HashMap 是 Java 中最常用的集合类之一,下面通过几个实际案例来演示如何使用。
基础使用案例
import java.util.HashMap;
import java.util.Map;
public class BasicHashMapExample {
public static void main(String[] args) {
// 1. 创建HashMap
HashMap<String, Integer> scores = new HashMap<>();
// 2. 添加元素
scores.put("张三", 95);
scores.put("李四", 88);
scores.put("王五", 92);
scores.put("赵六", 78);
// 3. 获取元素
System.out.println("张三的成绩: " + scores.get("张三"));
// 4. 判断是否包含key
boolean hasLiSi = scores.containsKey("李四");
System.out.println("是否包含李四: " + hasLiSi);
// 5. 判断是否包含value
boolean hasScore95 = scores.containsValue(95);
System.out.println("是否有95分: " + hasScore95);
// 6. 获取大小
System.out.println("学生人数: " + scores.size());
// 7. 删除元素
scores.remove("赵六");
System.out.println("删除赵六后人数: " + scores.size());
// 8. 清空HashMap
// scores.clear();
}
}
遍历HashMap的多种方式
import java.util.HashMap;
import java.util.Map;
public class HashMapIterationExample {
public static void main(String[] args) {
HashMap<String, String> cities = new HashMap<>();
cities.put("北京", "首都");
cities.put("上海", "魔都");
cities.put("广州", "羊城");
cities.put("深圳", "鹏城");
// 方式1: 使用 entrySet 遍历
System.out.println("=== 方式1: entrySet ===");
for (Map.Entry<String, String> entry : cities.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
// 方式2: 使用 keySet 遍历
System.out.println("\n=== 方式2: keySet ===");
for (String key : cities.keySet()) {
System.out.println(key + " -> " + cities.get(key));
}
// 方式3: 使用 values 遍历
System.out.println("\n=== 方式3: values ===");
for (String value : cities.values()) {
System.out.println("城市别称: " + value);
}
// 方式4: 使用 Lambda 表达式 (Java 8+)
System.out.println("\n=== 方式4: Lambda ===");
cities.forEach((key, value) -> {
System.out.println(key + " -> " + value);
});
// 方式5: 使用 Stream API (Java 8+)
System.out.println("\n=== 方式5: Stream API ===");
cities.entrySet().stream()
.filter(entry -> entry.getKey().startsWith("北"))
.forEach(System.out::println);
}
}
学生成绩管理系统案例
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.List;
public class StudentGradeSystem {
private HashMap<String, ArrayList<Integer>> studentGrades;
public StudentGradeSystem() {
studentGrades = new HashMap<>();
}
// 添加学生成绩
public void addGrade(String name, int grade) {
studentGrades.computeIfAbsent(name, k -> new ArrayList<>()).add(grade);
}
// 获取学生平均分
public double getAverage(String name) {
ArrayList<Integer> grades = studentGrades.get(name);
if (grades == null || grades.isEmpty()) {
return 0.0;
}
return grades.stream().mapToInt(Integer::intValue).average().orElse(0.0);
}
// 获取所有学生的平均分
public Map<String, Double> getAllAverages() {
Map<String, Double> averages = new HashMap<>();
for (Map.Entry<String, ArrayList<Integer>> entry : studentGrades.entrySet()) {
averages.put(entry.getKey(), getAverage(entry.getKey()));
}
return averages;
}
// 打印所有成绩
public void printAllGrades() {
studentGrades.forEach((name, grades) -> {
System.out.println(name + ": " + grades + " (平均分: " + getAverage(name) + ")");
});
}
public static void main(String[] args) {
StudentGradeSystem system = new StudentGradeSystem();
// 添加学生成绩
system.addGrade("张三", 85);
system.addGrade("张三", 90);
system.addGrade("张三", 88);
system.addGrade("李四", 75);
system.addGrade("李四", 82);
system.addGrade("王五", 95);
// 打印所有成绩
system.printAllGrades();
// 获取特定学生平均分
System.out.println("\n张三平均分: " + system.getAverage("张三"));
// 获取所有学生平均分
System.out.println("\n所有学生平均分: " + system.getAllAverages());
}
}
单词计数器案例
import java.util.HashMap;
import java.util.Map;
public class WordCounter {
public static Map<String, Integer> countWords(String text) {
Map<String, Integer> wordCount = new HashMap<>();
// 清理文本并分割单词
String[] words = text.toLowerCase()
.replaceAll("[^a-zA-Z\\s]", "")
.split("\\s+");
for (String word : words) {
if (!word.isEmpty()) {
// 方法1: 传统方式
// if (wordCount.containsKey(word)) {
// wordCount.put(word, wordCount.get(word) + 1);
// } else {
// wordCount.put(word, 1);
// }
// 方法2: 使用 getOrDefault
// wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
// 方法3: 使用 merge (Java 8+)
wordCount.merge(word, 1, Integer::sum);
}
}
return wordCount;
}
public static void main(String[] args) {
String text = "Hello World Hello Java Hello World Java Programming";
Map<String, Integer> wordCount = countWords(text);
System.out.println("单词统计结果:");
wordCount.forEach((word, count) -> {
System.out.println(word + ": " + count + "次");
});
// 找出出现次数最多的单词
String mostFrequent = wordCount.entrySet()
.stream()
.max(Map.Entry.comparingByValue())
.map(Map.Entry::getKey)
.orElse("无");
System.out.println("\n出现最多的单词: " + mostFrequent +
" (" + wordCount.get(mostFrequent) + "次)");
}
}
缓存实现案例
import java.util.HashMap;
import java.util.Map;
public class SimpleCache<K, V> {
private final Map<K, V> cache = new HashMap<>();
private final long ttl; // 过期时间（毫秒）
private final Map<K, Long> timestamps = new HashMap<>();
public SimpleCache(long ttl) {
this.ttl = ttl;
}
// 添加缓存
public void put(K key, V value) {
cache.put(key, value);
timestamps.put(key, System.currentTimeMillis());
System.out.println("缓存添加: " + key + " -> " + value);
}
// 获取缓存
public V get(K key) {
Long timestamp = timestamps.get(key);
if (timestamp == null) {
return null;
}
// 检查是否过期
if (System.currentTimeMillis() - timestamp > ttl) {
cache.remove(key);
timestamps.remove(key);
System.out.println("缓存已过期: " + key);
return null;
}
return cache.get(key);
}
// 清除过期缓存
public void clearExpired() {
long now = System.currentTimeMillis();
timestamps.entrySet().removeIf(entry -> {
if (now - entry.getValue() > ttl) {
cache.remove(entry.getKey());
return true;
}
return false;
});
}
// 获取缓存大小
public int size() {
return cache.size();
}
public static void main(String[] args) throws InterruptedException {
// 创建5秒过期时间的缓存
SimpleCache<String, String> cache = new SimpleCache<>(5000);
// 添加缓存
cache.put("user1", "张三");
cache.put("user2", "李四");
// 立即获取
System.out.println("立即获取: " + cache.get("user1"));
// 等待3秒
Thread.sleep(3000);
System.out.println("3秒后获取: " + cache.get("user1"));
// 等待3秒（总共6秒，超过5秒）
Thread.sleep(3000);
System.out.println("6秒后获取: " + cache.get("user1"));
System.out.println("当前缓存大小: " + cache.size());
// 清除过期缓存
cache.clearExpired();
System.out.println("清除后缓存大小: " + cache.size());
}
}
HashMap 常用方法和注意事项
import java.util.HashMap;
import java.util.Map;
public class HashMapTipsExample {
public static void main(String[] args) {
// 1. 初始化容量和负载因子
HashMap<String, Integer> map1 = new HashMap<>(16, 0.75f);
// 2. 使用 putIfAbsent 避免覆盖
Map<String, String> config = new HashMap<>();
config.put("timeout", "5000");
config.putIfAbsent("timeout", "10000"); // 不会覆盖
System.out.println("timeout: " + config.get("timeout")); // 输出: 5000
// 3. 使用 computeIfAbsent 懒加载
Map<String, List<String>> groups = new HashMap<>();
groups.computeIfAbsent("group1", k -> new ArrayList<>()).add("member1");
System.out.println("group1: " + groups.get("group1"));
// 4. 使用 getOrDefault 避免空指针
Map<String, Integer> scores = new HashMap<>();
scores.put("张三", 95);
System.out.println("李四成绩: " + scores.getOrDefault("李四", 0));
// 5. 使用 replace 方法
scores.replace("张三", 95, 100); // 只有当值为95时才替换为100
System.out.println("张三新成绩: " + scores.get("张三"));
// 6. 合并操作
scores.merge("张三", 10, Integer::sum); // 如果存在则相加，否则添加
System.out.println("张三合并后成绩: " + scores.get("张三"));
// 7. 注意事项：自定义对象作为key时需要重写equals和hashCode
Map<Person, String> personMap = new HashMap<>();
personMap.put(new Person("张三", 20), "学生");
personMap.put(new Person("李四", 25), "老师");
System.out.println("张三角色: " + personMap.get(new Person("张三", 20)));
}
static class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@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 && name.equals(person.name);
}
@Override
public int hashCode() {
return 31 * name.hashCode() + age;
}
}
}
HashMap 的主要特点：
- 基于哈希表实现，查询速度 O(1)
- 允许 null 键和 null 值
- 非线程安全
- 无序（不保证顺序）
使用建议：
- 预估容量，避免频繁扩容
- 自定义对象作为 key 时重写 equals 和 hashCode
- 多线程环境使用 ConcurrentHashMap
- 需要有序时使用 LinkedHashMap 或 TreeMap
这些案例涵盖了 HashMap 的常见使用场景,你可以根据实际需求选择合适的实现方式。
