C# HashSet 教程：基础概念、方法与实际应用 – wiki词典

作者： /

C# HashSet 教程：基础概念、方法与实际应用

在 C# 编程中，HashSet<T> 是 System.Collections.Generic 命名空间下的一个强大集合类型，它专注于存储不重复的元素并提供高效的集合操作。如果你需要在集合中确保元素的唯一性，并且需要快速地执行添加、删除和查找操作，那么 HashSet<T> 是一个理想的选择。

1. 基础概念 (Basic Concepts)

HashSet<T> 的核心特性使其在特定场景下表现出色：

  • 唯一性 (Uniqueness)：这是 HashSet 最重要的特性。它保证集合中的每一个元素都是唯一的，不允许存在重复项。当你尝试添加一个已经存在于 HashSet 中的元素时，添加操作将不起作用，集合内容不会改变。
  • 无序性 (Unordered)：HashSet 中的元素没有特定的顺序。元素被添加的顺序并不能保证它们在迭代时会以相同的顺序出现。这意味着你不能通过索引来访问 HashSet 中的元素。
  • 高性能 (Performance)：对于 Add、Remove 和 Contains 等基本操作，HashSet 通常能提供平均 O(1)（常数时间）的性能复杂度，前提是元素类型 T 的哈希函数设计良好。在最坏情况下（例如，大量哈希冲突），性能可能会退化到 O(n)。
  • 内部机制 (Internal Mechanism)：HashSet<T> 内部使用哈希表来存储元素。当一个元素被添加时，系统会计算其哈希码（通过调用元素类型 T 的 GetHashCode() 方法）。这个哈希码决定了元素在内部数据结构中的存储位置。当需要检查唯一性或查找元素时，哈希码被用来快速定位可能的元素位置。如果两个元素的哈希码相同，HashSet 还会进一步使用 Equals() 方法来判断它们是否真正相等。

为了确保 HashSet 的正确性和效率，存储在其中的类型 T 应该正确地实现 GetHashCode() 和 Equals() 方法。对于 int、string、DateTime 等内置类型，这些方法已经正确实现。对于自定义引用类型，你可能需要重写这些方法。

2. 常用方法与示例 (Common Methods and Examples)

下面是 HashSet<T> 的一些最常用方法及其代码示例：

“`csharp
using System;
using System.Collections.Generic;
using System.Linq; // 用于方便的LINQ扩展方法，如ToList()

public class HashSetTutorial
{
public static void Main(string[] args)
{
// 1. 创建 HashSet
HashSet fruits = new HashSet();
Console.WriteLine(“— 初始 HashSet —“);
PrintHashSet(fruits); // 输出: Count: 0, Elements: (empty)

    // 2. Add(T item) - 向集合添加元素。如果添加成功返回 true，如果元素已存在则返回 false。
    Console.WriteLine("\n--- Add 方法 ---");
    Console.WriteLine($"添加 'Apple': {fruits.Add("Apple")}");    // 输出: True
    Console.WriteLine($"添加 'Banana': {fruits.Add("Banana")}");  // 输出: True
    Console.WriteLine($"添加 'Orange': {fruits.Add("Orange")}");  // 输出: True
    Console.WriteLine($"再次添加 'Apple': {fruits.Add("Apple")}"); // 输出: False (重复元素)
    PrintHashSet(fruits); // 输出: Count: 3, Elements: Apple, Banana, Orange (顺序可能不同)

    // 3. Contains(T item) - 检查集合是否包含某个元素。
    Console.WriteLine("\n--- Contains 方法 ---");
    Console.WriteLine($"包含 'Banana': {fruits.Contains("Banana")}"); // 输出: True
    Console.WriteLine($"包含 'Grape': {fruits.Contains("Grape")}");   // 输出: False

    // 4. Remove(T item) - 从集合中移除元素。如果移除成功返回 true，如果元素不存在则返回 false。
    Console.WriteLine("\n--- Remove 方法 ---");
    Console.WriteLine($"移除 'Banana': {fruits.Remove("Banana")}"); // 输出: True
    Console.WriteLine($"移除 'Grape': {fruits.Remove("Grape")}");   // 输出: False (未找到)
    PrintHashSet(fruits); // 输出: Count: 2, Elements: Apple, Orange (顺序可能不同)

    // 5. Clear() - 移除集合中的所有元素。
    // fruits.Clear();
    // Console.WriteLine("\n--- Clear 方法 ---");
    // PrintHashSet(fruits); // 输出: Count: 0, Elements: (empty)

    // 6. Count - 获取集合中元素的数量。
    Console.WriteLine($"\n--- Count 属性 ---");
    Console.WriteLine($"当前水果数量: {fruits.Count}"); // 输出: 2

    // --- 集合操作 ---
    HashSet<string> tropicalFruits = new HashSet<string> { "Banana", "Mango", "Pineapple", "Orange" };
    HashSet<string> citrusFruits = new HashSet<string> { "Orange", "Lemon", "Lime" };

    Console.WriteLine("\n--- 集合操作 ---");
    Console.WriteLine("水果 (fruits): " + string.Join(", ", fruits)); // Apple, Orange
    Console.WriteLine("热带水果 (tropicalFruits): " + string.Join(", ", tropicalFruits)); // Banana, Mango, Pineapple, Orange
    Console.WriteLine("柑橘类水果 (citrusFruits): " + string.Join(", ", citrusFruits)); // Orange, Lemon, Lime

    // 7. UnionWith(IEnumerable<T> other) - 将当前集合修改为包含自身、指定集合或两者中都存在的所有元素（并集）。
    HashSet<string> allFruits = new HashSet<string>(fruits); // 创建一个副本以保留原始 'fruits'
    allFruits.UnionWith(tropicalFruits);
    Console.WriteLine("\n并集 (fruits U tropicalFruits): " + string.Join(", ", allFruits));
    // 预期: Apple, Orange, Banana, Mango, Pineapple (顺序可能不同)

    // 8. IntersectWith(IEnumerable<T> other) - 将当前集合修改为只包含与指定集合中也存在的元素（交集）。
    HashSet<string> commonFruits = new HashSet<string>(fruits); // Apple, Orange
    commonFruits.IntersectWith(tropicalFruits); // 与 Banana, Mango, Pineapple, Orange 的交集
    Console.WriteLine("交集 (fruits ^ tropicalFruits): " + string.Join(", ", commonFruits));
    // 预期: Orange

    // 9. ExceptWith(IEnumerable<T> other) - 从当前集合中移除指定集合中存在的所有元素（差集）。
    HashSet<string> nonTropicalFruits = new HashSet<string>(fruits); // Apple, Orange
    nonTropicalFruits.ExceptWith(tropicalFruits); // 移除 Banana, Mango, Pineapple, Orange
    Console.WriteLine("差集 (fruits - tropicalFruits): " + string.Join(", ", nonTropicalFruits));
    // 预期: Apple

    // 10. SymmetricExceptWith(IEnumerable<T> other) - 将当前集合修改为只包含在当前集合或指定集合中存在，但不同时存在于两者中的元素（对称差集）。
    HashSet<string> uniqueToEither = new HashSet<string>(fruits); // Apple, Orange
    uniqueToEither.SymmetricExceptWith(tropicalFruits); // 存在于 fruits 或 tropicalFruits 中，但不同时存在于两者中
    Console.WriteLine("对称差集 (fruits XOR tropicalFruits): " + string.Join(", ", uniqueToEither));
    // 预期: Apple, Banana, Mango, Pineapple (顺序可能不同)

    // 11. IsSubsetOf(IEnumerable<T> other) - 判断当前集合是否是指定集合的子集。
    HashSet<string> smallSet = new HashSet<string> { "Apple" };
    Console.WriteLine($"\n{{'Apple'}} 是 fruits 的子集吗: {smallSet.IsSubsetOf(fruits)}"); // True
    Console.WriteLine($"fruits 是 tropicalFruits 的子集吗: {fruits.IsSubsetOf(tropicalFruits)}"); // False

    // 12. IsSupersetOf(IEnumerable<T> other) - 判断当前集合是否是指定集合的超集。
    Console.WriteLine($"fruits 是 {{'Apple'}} 的超集吗: {fruits.IsSupersetOf(smallSet)}"); // True
    Console.WriteLine($"tropicalFruits 是 fruits 的超集吗: {tropicalFruits.IsSupersetOf(fruits)}"); // False

    // 13. Overlaps(IEnumerable<T> other) - 判断当前集合与指定集合是否有共同元素。
    Console.WriteLine($"fruits 和 citrusFruits 有重叠吗: {fruits.Overlaps(citrusFruits)}"); // True (Orange)
    HashSet<string> berries = new HashSet<string> { "Strawberry", "Blueberry" };
    Console.WriteLine($"fruits 和 berries 有重叠吗: {fruits.Overlaps(berries)}"); // False

    // 14. SetEquals(IEnumerable<T> other) - 判断当前集合与指定集合是否包含相同的元素（忽略顺序）。
    HashSet<string> anotherFruits = new HashSet<string> { "Orange", "Apple" };
    Console.WriteLine($"fruits 和 {{'Orange', 'Apple'}} 相等吗: {fruits.SetEquals(anotherFruits)}"); // True
    Console.WriteLine($"fruits 和 tropicalFruits 相等吗: {fruits.SetEquals(tropicalFruits)}"); // False
}

// 辅助方法：打印 HashSet 的内容
public static void PrintHashSet<T>(HashSet<T> set)
{
    Console.Write($"数量 (Count): {set.Count}, 元素 (Elements): ");
    if (set.Any())
    {
        Console.WriteLine(string.Join(", ", set));
    }
    else
    {
        Console.WriteLine(" (空)");
    }
}

}
“`

3. 实际应用 (Practical Applications)

HashSet<T> 在以下场景中特别有用：

  1. 存储唯一项 (Storing Unique Items)：当你需要一个集合来确保元素没有重复时。

    • 示例：从文档中收集所有不重复的单词，跟踪访问页面的唯一用户 ID。

    csharp
    // 应用: 收集不重复的单词
    string text = "the quick brown fox jumps over the lazy dog the quick brown fox";
    string[] words = text.Split(' ');
    HashSet<string> uniqueWords = new HashSet<string>(words);
    Console.WriteLine("\n--- 实际应用: 不重复的单词 ---");
    Console.WriteLine("不重复的单词: " + string.Join(", ", uniqueWords));
    // 预期: the, quick, brown, fox, jumps, over, lazy, dog (顺序可能不同)

  2. 快速成员资格测试 (Fast Membership Testing)：当你需要频繁地检查某个项是否已经存在于集合中时。

    • 示例：过滤列表以去除重复项，检查用户是否具有某个特定权限（从大量权限中）。

    “`csharp
    // 应用: 从列表中过滤重复项
    List numbersWithDuplicates = new List { 1, 2, 3, 2, 4, 1, 5, 3 };
    HashSet seenNumbers = new HashSet();
    List uniqueNumbers = new List();

    foreach (int num in numbersWithDuplicates)
    {
    if (seenNumbers.Add(num)) // Add 方法返回 true 如果该项是新添加的
    {
    uniqueNumbers.Add(num);
    }
    }
    Console.WriteLine(“\n— 实际应用: 过滤重复项 —“);
    Console.WriteLine(“原始列表: ” + string.Join(“, “, numbersWithDuplicates));
    Console.WriteLine(“不重复的数字 (保留顺序): ” + string.Join(“, “, uniqueNumbers));
    // 预期: 1, 2, 3, 4, 5
    “`

  3. 执行集合操作 (Performing Set Operations)：当你需要查找两个集合之间的共同元素、差异或组合时。

    • 示例：查找两个不同组的共同用户，识别在一个软件版本中存在而在另一个版本中不存在的功能。

    “`csharp
    // 应用: 查找共同兴趣
    HashSet user1Interests = new HashSet { “Reading”, “Hiking”, “Cooking”, “Gaming” };
    HashSet user2Interests = new HashSet { “Gaming”, “Photography”, “Reading”, “Traveling” };

    HashSet commonInterests = new HashSet(user1Interests);
    commonInterests.IntersectWith(user2Interests);
    Console.WriteLine(“\n— 实际应用: 共同兴趣 —“);
    Console.WriteLine(“用户1兴趣: ” + string.Join(“, “, user1Interests));
    Console.WriteLine(“用户2兴趣: ” + string.Join(“, “, user2Interests));
    Console.WriteLine(“共同兴趣: ” + string.Join(“, “, commonInterests));
    // 预期: Reading, Gaming (顺序可能不同)

    HashSet user1OnlyInterests = new HashSet(user1Interests);
    user1OnlyInterests.ExceptWith(user2Interests);
    Console.WriteLine(“用户1独有兴趣: ” + string.Join(“, “, user1OnlyInterests));
    // 预期: Hiking, Cooking (顺序可能不同)
    “`

总结 (Conclusion)

HashSet<T> 是 C# 中一个功能强大且高效的集合，用于管理唯一元素和执行基于集合的逻辑。其卓越的性能特性使其成为许多数据处理和过滤任务的首选工具。理解和熟练使用 HashSet<T> 将极大地提高你在 C# 项目中处理数据集合的效率和代码的简洁性。
“`

滚动至顶部