跳转至

Java HashMap vs HashSet：深入解析与实践

简介

在 Java 编程中，HashMap 和 HashSet 是两个非常重要且常用的集合类。它们都基于哈希表实现，提供了高效的数据存储和检索方式。然而，它们在功能和使用场景上有着明显的区别。理解这些区别对于选择合适的数据结构来解决实际问题至关重要。本文将详细介绍 HashMap 和 HashSet 的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这两个类。

目录

  1. 基础概念
    • HashMap
    • HashSet
  2. 使用方法
    • HashMap
    • HashSet
  3. 常见实践
    • HashMap
    • HashSet
  4. 最佳实践
    • HashMap
    • HashSet
  5. 小结
  6. 参考资料

基础概念

HashMap

HashMap 是一个基于哈希表实现的键值对（key-value）集合。它允许 null 键和 null 值，并且不保证元素的顺序。每个键值对被称为一个 Entry，HashMap 通过计算键的哈希值来确定其在哈希表中的存储位置，从而实现快速的查找和插入操作。

HashSet

HashSet 是一个基于哈希表实现的无序集合。它不允许重复元素，即每个元素在集合中是唯一的。HashSet 内部实际上是通过 HashMap 来实现的，每个元素作为 HashMap 的键存储，值则使用一个固定的对象 PRESENT。同样，它也不保证元素的顺序，并且允许 null 元素。

使用方法

HashMap

  1. 创建 HashMap
import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // 创建一个空的 HashMap
        Map<String, Integer> map = new HashMap<>();
        // 创建一个带有初始容量的 HashMap
        Map<String, Integer> mapWithCapacity = new HashMap<>(16);
        // 创建一个带有初始容量和负载因子的 HashMap
        Map<String, Integer> mapWithCapacityAndLoadFactor = new HashMap<>(16, 0.75f);
    }
}
  1. 添加键值对
import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);
    }
}
  1. 获取值
import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);

        Integer value = map.get("two");
        System.out.println("Value for key 'two': " + value);
    }
}
  1. 遍历 HashMap
import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);

        // 遍历键
        for (String key : map.keySet()) {
            System.out.println("Key: " + key);
        }

        // 遍历值
        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }

        // 遍历键值对
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

HashSet

  1. 创建 HashSet
import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        // 创建一个空的 HashSet
        Set<String> set = new HashSet<>();
        // 创建一个带有初始容量的 HashSet
        Set<String> setWithCapacity = new HashSet<>(16);
        // 创建一个带有初始容量和负载因子的 HashSet
        Set<String> setWithCapacityAndLoadFactor = new HashSet<>(16, 0.75f);
    }
}
  1. 添加元素
import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("cherry");
    }
}
  1. 检查元素是否存在
import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("cherry");

        boolean containsApple = set.contains("apple");
        System.out.println("Set contains 'apple': " + containsApple);
    }
}
  1. 遍历 HashSet
import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("cherry");

        for (String element : set) {
            System.out.println("Element: " + element);
        }
    }
}

常见实践

HashMap

  1. 统计单词出现次数
import java.util.HashMap;
import java.util.Map;

public class WordCountExample {
    public static void main(String[] args) {
        String text = "this is a sample text this is another sample";
        String[] words = text.split(" ");

        Map<String, Integer> wordCountMap = new HashMap<>();
        for (String word : words) {
            wordCountMap.put(word, wordCountMap.getOrDefault(word, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : wordCountMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}
  1. 缓存数据
import java.util.HashMap;
import java.util.Map;

public class CacheExample {
    private static final Map<Integer, String> cache = new HashMap<>();

    public static String getDataFromCacheOrFetch(int key) {
        String value = cache.get(key);
        if (value == null) {
            // 模拟从数据库或其他数据源获取数据
            value = "Data for key " + key;
            cache.put(key, value);
        }
        return value;
    }

    public static void main(String[] args) {
        System.out.println(getDataFromCacheOrFetch(1));
        System.out.println(getDataFromCacheOrFetch(1));
    }
}

HashSet

  1. 去重操作
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateRemovalExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(3);
        list.add(3);

        Set<Integer> set = new HashSet<>(list);
        List<Integer> uniqueList = new ArrayList<>(set);

        System.out.println("Unique list: " + uniqueList);
    }
}
  1. 检查集合中是否有重复元素
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateCheckExample {
    public static boolean hasDuplicates(List<Integer> list) {
        Set<Integer> set = new HashSet<>();
        for (Integer num : list) {
            if (!set.add(num)) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        System.out.println("List 1 has duplicates: " + hasDuplicates(list1));

        List<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(2);
        System.out.println("List 2 has duplicates: " + hasDuplicates(list2));
    }
}

最佳实践

HashMap

  1. 合理设置初始容量和负载因子
    • 初始容量：如果能够预估键值对的数量，设置合适的初始容量可以减少哈希表的扩容次数，提高性能。例如，如果预计有 100 个键值对，初始容量设置为 128（大于 100 的 2 的幂次方）。
    • 负载因子：默认负载因子为 0.75，这是一个平衡了空间和时间效率的值。如果对空间要求较高，可以适当降低负载因子；如果对性能要求较高，可适当提高负载因子，但会增加哈希冲突的可能性。
  2. 使用不可变对象作为键
    • 使用不可变对象（如 String、Integer 等）作为键可以确保哈希值的稳定性。因为如果键的内容发生变化，其哈希值也会改变，可能导致在 HashMap 中查找不到对应的键值对。
  3. 遍历 HashMap 时使用 entrySet()
    • 当需要同时获取键和值时，使用 entrySet() 遍历比分别使用 keySet() 和 values() 遍历效率更高，因为它避免了多次查找操作。

HashSet

  1. 正确重写 hashCode() 和 equals() 方法
    • 为了确保 HashSet 能够正确判断元素的唯一性，自定义类需要正确重写 hashCode() 和 equals() 方法。这两个方法的实现应该遵循一定的规则，即如果两个对象 equals() 方法返回 true，那么它们的 hashCode() 方法返回值必须相同；反之，如果两个对象 hashCode() 方法返回值相同，它们不一定 equals()。
  2. 批量添加元素
    • 如果需要添加多个元素到 HashSet 中，可以先将这些元素添加到一个 Collection 中，然后使用 HashSet 的构造函数或 addAll() 方法一次性添加，这样比逐个添加效率更高。

小结

HashMap 和 HashSet 都是 Java 中非常强大的集合类，它们基于哈希表实现，提供了高效的数据存储和检索功能。HashMap 用于存储键值对，适用于需要根据键来查找值的场景；而 HashSet 用于存储唯一元素，适用于去重、检查元素唯一性等场景。在实际应用中，需要根据具体的需求选择合适的数据结构，并遵循最佳实践来优化性能。

参考资料

  1. Oracle Java Documentation - HashMap
  2. Oracle Java Documentation - HashSet
  3. 《Effective Java》 by Joshua Bloch