C# 的 HashSet

表示一个对象集合。

public class HashSet<T> : System . Collections . Generic . ICollection < T > , System . Collections . Generic . IEnumerable < T > , System . Collections . Generic . IReadOnlyCollection < T > , System . Collections . Generic . IReadOnlySet < T > , System . Collections . Generic . ISet < T > , System . Runtime . Serialization . IDeserializationCallback , System . Runtime . Serialization . ISerializable

参数

继承

实现

ICollection < T >，IEnumerable < T >，IReadOnlyCollection < T >，ISet < T >，ICollection，IEnumerable，IReadOnlySet < T >，IDeserializationCallback，ISerializable

示例

以下示例演示了两个 HashSet < T > 类，并分别用偶数和奇数填充它们。第三个 HashSet < T > 对象是从包含偶数的集合创建的。然后，该示例调用 UnionWith 方法，该方法将奇数集合添加到第三个集合中（注意，第三个如果是个 SortedSet，输出将是排序的）。

HashSet < int > ZHSs2 = [ ] , ZHSsF2 = [ ] ;
for ( int z = 0 ; z < 5  ; z++ )
    {
    // 填充偶数集
    ZHSs2 . Add ( z * 2 );
    // 填充奇数集
    ZHSsF2 . Add ( z * 2 + 1 );
    }
Console . WriteLine ( "所有的奇数：" );
FF显示Set ( ZHSsF2 );

Console . WriteLine ( "所有的偶数：" );
FF显示Set ( ZHSs2 );

// 创建一个新的 HashSet 填充“偶数集”
HashSet < int > ZHSs = [ .. ZHSs2 ];
Console . WriteLine ( "现在生成奇数和偶数的并集：" );
ZHSs . UnionWith ( ZHSsF2 );
FF显示Set ( ZHSs );

SortedSet < int > ZHSs排序 = [ .. ZHSs2 ];
Console . WriteLine ( "现在生成奇数和偶数的并集（排序）：" );
ZHSs排序 . UnionWith ( ZHSsF2 );
FF显示Set ( ZHSs排序 );

static void FF显示Set ( ISet < int > 集合 )
    {
    Console . Write ( "{" );
    foreach ( int z in 集合 )
        {
        Console.Write ( $"\t{z}" ); 
        }
    Console . WriteLine ( "\t}" );
    }

关于集和集合

集可以用于描述 Collection，其内部可能是多种类型、没有顺序、可能重复的元素。而集合，即 Set，用于单类型、可以排序、去重的列表。

集可类比你逛大街，卖啥的都有，例如几家卖包子的；集合可类比你进了一家包子铺，商品琳琅满目，但都是包子，而且可能给你照食材、价格等因素排列好（SortedSet 会排序，HashSet 不会），但一定是一种包子一个食盘，挑着吃就是了。

构造函数

备注

此构造函数是一个 O（1）操作。

public HashSet ( );
public HashSet ( int 初始容量 );
public HashSet ( int 初始容量 , IEqualityComparer < T > 比较器 );
public HashSet ( System . Collections . Generic . IEnumerable < T > 集或集合);
public HashSet ( System . Collections . Generic . IEqualityComparer < T > ? 比较器 );
public HashSet ( System . Collections . Generic . IEnumerable < T > 集或集合 , System . Collections . Generic . IEqualityComparer < T >? 比较器 );

参数

异常

示例

基础示例中，已经展示了未使用 比较器 产生新的 HashSet 的方式，下面的示例使用已存在的集合和特殊的比较器创建新的 HashSet：

HashSet < string > ZFCs我的颜色 = new ( StringComparer . InvariantCultureIgnoreCase )
    {
    "红" , "Red" , "red" , "绿" , "Lv"
    };

ZFCs我的颜色 . Add ( "蓝" );
ZFCs我的颜色 . Add ( "Blue" );
ZFCs我的颜色 . Add ( "blue" );

foreach ( var z in ZFCs我的颜色 )
    {
    Console . Write ( $"{z}\t" );
    }
Console . WriteLine ( );

备注

HashSet < T > 对象的容量是该对象可以容纳的元素数量。当向 HashSet < T > 对象添加元素时，其容量会自动增加。

如果 集或集合 包含重复项，则该 集或集合 将包含每个唯一元素中的一个。不会抛出异常。因此，结果集合的大小可能与 集或集合 的大小不同。

由于调整大小相对耗时（需要重新哈希），因此这会根据 初始容量 的值设置初始容量，以尽量减少调整大小的需求。

此构造函数是一个 O（1）（未指定 集或集合 参数）或 O（n）操作，n 为 集或集合 . Count。

属性

Capatity

获取内部数据结构在不调整大小的情况下可容纳的元素总数。
public int Capacity { get; }

属性值

备注

检索此属性的值是一个 O（1）操作。

Comparer

获取用于对 HashSet < T > 中的值的相等性的 IEqualityComparer < T > 对象。
public System . Collections . Generic . IEqualityComparer < T > 比较器 { get; }

属性值

备注

返回的比较器可以是 HashSet < T > 类型的默认比较器，也可以是其构造函数所使用的比较器。

检索此属性的值是一个 O（1）操作。

Count

获取 HashSet < T > 中的元素的数量。
public Int Count { get; }

属性值

实现

Count ( )

备注

检索此属性的值是一个 O（1）操作。

方法

Add 和 Remove

向集合添加或删除一个元素，并返回一个值，该值指示是否成功添加或删除了该元素。

public bool Add ( T 项目 );
public bool Remove ( T 项目 );

返回值

备注

HashSet < T > 类不接受重复元素。如果 项目 已在集合中，Add 方法会返回 false 且不会抛出异常。

如果计数已等于 HashSet < T > 对象的容量，则会自动调整容量以容纳新项。

如果 HashSet < T > 对象不包含指定元素，则移除该对象的元素该对象保持不变，且不会抛出异常。

对于引用类型，项目 可以为 null。

Add 方法是一个O（1）操作（仅当需要调整 HashSet 的 Capacity 时，是个 O（n）操作，n 是调整后的 Capacity）；Remove 方法是一个 O（1）操作。

Clear

在 HashSet 中移除所有元素。
public void Clear ( );

实现

Clear ( )

备注

此方法不会缩小 HashSet 的 Capacity 属性。

此方法是一个 O（n）操作，其中 n 为 HashSet . Count。

Contains

确定 HashSet 中是否包含特定元素。
public bool Contains ( T 项目 );

参数

返回值

实现

Contains ( )

备注

此方法是一个 O（1）操作。

CopyTo

将 HashSet < T > 的一部分或全部复制到兼容的一维数组中，从目标数组的开头或指定索引处开始。

重载

public void CopyTo ( T [ ] 数组 );
public void CopyTo ( T [ ] 数组 , int 起始索引 );
public void CopyTo ( T [ ] 数组 , int 起始索引 , int 元素数 );

参数

实现

CopyTo ( T [ ] , Int32 )

异常

备注

数组 必须是一维的，以 0 为起始索引的，且能容纳 HashSet 元素类型的数组。

复制一定是自 HashSet 启始元素开始，复制整个 HashSet 或指定 元素数 为止。起始索引 只和目标数组有关。因为 HashSet 没有索引器。

此方法是一个 O（n）操作，其中 n 为 HashSet . Count 或指定 元素数。

CreateSetComparer

返回一个 IEqualityComparer 对象，该对象可用于创建包含各个 HashSet 的集合。

public static System . Collections . Generic . IEqualityComparer < System . Collections . Generic . HashSet < T > > CreateSetComparer ( );

返回值

备注

IEqualityComparer 对象仅在一个级别检查相等性；但是，您可以在其他级别将比较器链接在一起，以执行更深入的相等性测试。

调用此方法是一个 O（1）操作。

EnsureCapacity

确保 HashSet 能够容纳多达指定数量的条目，而无需进一步扩展其后备存储。
public int EnsureCapacity ( int 目标容量 );

参数

返回值

异常

ExceptWith

从当前的 HashSet < T > 对象中移除所有存在于指定集或集合中的元素（差集）。
public void ExceptWith ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

实现

ExceptWith ( IEnumerable < T > )

异常

示例

IEnumerable < double > ZHSs = [ 3 , 1 , 0 , -3 , 3 , 7 ];
IEnumerable < double > SJDs = [ 6.5 , 21.3 , -10 , -30.6 , 13.8 , 17.6 , 13.8 , 1 , 3 , 3 ];
HashSet < double > ZHSs未排序 = [ .. ZHSs ];
HashSet < double > SJDs未排序 = [ .. SJDs ];

ZHSs未排序 . ExceptWith ( SJDs未排序 );
foreach ( var z in ZHSs未排序 )
    { Console . WriteLine ( z ); }

备注

此方法会移除当前 HashSet < T > 中同时存在于 另一个 中的任何元素。另一个（如果是集）中的重复值会被忽略。

该方法等同于数学上的 A - B。

此方法是一个 O（n）操作，n 为 另一个 . Count。

GetAlternateLookup

获取一个类型的实例，该实例可用于使用 T替代 而非 T 对当前的 HashSet < T > 执行操作。
public System . Collections . Generic . HashSet < T > . AlternateLookup < T替代 > GetAlternateLookup < T替代 > ( ) where T替代 : allows ref struct;

参数

返回值

异常

示例

该示例创建了一个名称 HashSet，展示了如何使用 int 值搜索 HashSet 中的元素：

using System . Text;

public class NameToIntComparer : EqualityComparer < string > , IAlternateEqualityComparer < int , string > // 比较器必须实现 IAlternateEqualityComparer 接口
    {
    // 替代键（int）相等比较
    public bool Equals ( int x , int y ) => x == y;
    public int MapToAlternate ( string 值 ) => FF替代映射 ( 值 );

    // 原类型→替代键映射（姓名→int哈希值）
    public int FF替代映射 ( string 值 )
        {
        return string . IsNullOrEmpty ( 值 ) ? 0 : 值 . GetHashCode ( StringComparison . Ordinal );
        }

    // 替代键哈希计算
    public int FF替代哈希码 ( int 替代键 ) => 替代键 . GetHashCode ( );

    // 原类型相等比较（重写基类方法）
    public override bool Equals ( string? x , string? y )
        {
        return ( x != null || y != null ) && string . Equals ( x , y );
        }

    // 原类型哈希计算（重写基类方法）
    public override int GetHashCode ( string 对象 ) => 对象 . GetHashCode ( StringComparison . Ordinal );

    public bool Equals ( int 替代 , string 另一个 )
        {
        // 原姓名 另一个 → 替代键int → 和传入的 替代 比较
        int zhs另一个替代键 = FF替代映射 ( 另一个 );
        return 替代 == zhs另一个替代键;
        }

    public int GetHashCode ( int 替代 )
        {
        return 替代 . GetHashCode ( );
        }

    public string Create ( int 替代 )
        {
        return 替代 . ToString ( );
        }
    }

public class Program
    {
    public static void Main ( )
        {
        Console . OutputEncoding = Encoding . UTF8;
        try
            {
            // ========== 步骤1：创建比较器 ==========
            NameToIntComparer bjq姓名 = new ( );

            // ========== 步骤2：初始化 HashSet（绑定比较器） ==========
            HashSet < string > ZFCs姓名 = new ( bjq姓名 );
            ZFCs姓名 . UnionWith (
            [
                "孙萌萌" , "李莲莲" , "马兰" , "穆兰英" , "肖静" , "巴玲玲" , "黄文静" , "钱月月"
            ] );

            // ========== 步骤3：创建替代查找视图（核心：基于 string 的 HashSet） ==========
            HashSet < string > . AlternateLookup < int > hxb替代查找视图 = ZFCs姓名 . GetAlternateLookup < int > ( );

            // ========== 步骤4：调用正确的 TryGetValue（out 参数是 string） ==========
            int zhs孙萌萌替代键 = bjq姓名 . FF替代映射 ( "孙萌萌" );
            bool 查找成功 = hxb替代查找视图 . TryGetValue ( zhs孙萌萌替代键 , out string? 匹配结果 );

            // ========== 步骤5：输出结果 ==========
            if ( 查找成功 != false && 匹配结果 != null )
                {
                Console . WriteLine ( $"✅ 查找成功！结果：{匹配结果}" );
                }
            else
                {
                Console . WriteLine ( "❌ 未找到匹配结果" );
                }

            // ========== 验证实时同步 ==========
            ZFCs姓名 . Remove ( "李莲莲" );
            int zhs李莲莲替代键 = bjq姓名 . FF替代映射( "李莲莲" );
            if ( !hxb替代查找视图 . TryGetValue ( zhs李莲莲替代键 , out _ ) )
                {
                Console . WriteLine ( $"✅ 删除「李莲莲」后，查找无结果（同步成功）" );
                }
            }
        catch ( Exception ex )
            {
            Console . WriteLine ( $"❌ 异常类型：{ex . GetType ( ) . Name}" );
            Console . WriteLine ( $"❌ 异常原因：{ex . Message}" );
            }
        }
    }

备注

该集合必须使用实现了 IAlternateEqualityComparer < T替代 , T > 的比较器，其中包含 T替代 和 T。如果不这样做，将会抛出异常。

IntersectWith

修改当前的 HashSet < T > 对象，使其仅包含也存在于指定集或集合中的元素。
public void IntersectWith ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

实现

IntersectWith ( IEnumerable < T > )

异常

备注

此方法忽略 另一个（若是集）中的任何重复元素。

执行 IntersectWith 方法后的 HashSet 对象仅包含原 HashSet 实例与 另一个 共同拥有的元素。等同于数学概念中的 A ∩ B。此时的 A 可能没有元素，因为 A ∩ B = ∅（没有共同元素）。

如果 另一个 参数所表示的集合是与当前 HashSet < T > 对象具有相同相等比较器的 HashSet < T > 集合，则此方法是一个 O（n） 操作。否则，此方法是一个 O（n + m）操作，其中 n 为原 HashSet . Count，m 为 另一个 . Count。

IsProperSubsetOf、IsProperSupersetOf、IsSubsetOf 和 IsSupersetOf

描述某个集或集合是否是当前实例的真子集、真超集、子集和超集。

public bool IsProperSubsetOf ( System . Collections . Generic . IEnumerable < T > 真子集 );
public bool IsProperSupersetOf ( System . Collections . Generic . IEnumerable < T > 真超集 );
public bool IsSubsetOf ( System . Collections . Generic . IEnumerable < T > 子集 );
public bool IsSupersetOf ( System . Collections . Generic . IEnumerable < T > 超集 );

参数

返回值

实现

IsProperSubsetOf ( IEnumerable < T > )
IsProperSupersetOf ( IEnumerable < T > )
IsSubsetOf ( IEnumerable < T > )
IsSupersetOf ( IEnumerable < T > )

异常

备注

若 HashSet A = [ 3 , 5 , 1 , 4 , 2 ]，B = [ 2 , 1 ]，则
A 是 B 的真超集，记作 A ⊃ B；B 是 A 的真子集，记作 B ⊂ A（同时也分别是超集（⊇）和子集（⊆））。

超集即包含该 HashSet 实例的所有元素的集合，真超集则还包含其他元素；子集即包含该 HashSet 实例的全部或部分元素的集合，真子集仅包含部分元素。

空的 HashSet 是任意集或集合的子集，是任意有元素的集或集合的真子集；任意集或集合是空的 HashSet 的超集，有元素的集或集合是空的 HashSet 的真超集。

如下表，这些方法将始终返回 false。

如果由 参数 表示的集或集合是与当前 HashSet < T > 对象具有相同相等比较器的 HashSet < T > 集合，则此方法是一个 O（n）操作。否则，此方法是一个 O（n + m）操作，其中 n 是 HashSet . Count，m 是 参数 . Count。

Overlaps

确定当前的 HashSet < T > 对象和指定的集或集合是否包含共同元素。
public bool Overlaps ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

返回值

实现

Overlaps ( IEnumerable < T > )

异常

备注

另一个（若是集）中的任何重复元素将被忽略。

该方法数学含义可表示为 A ∩ B ≠ ∅。即两集合或集有交集（有公共元素）。

此方法是一个 O（n）操作，其中 n 为 另一个 . Count。最简单的情况是 HashSet 实例或/和 另一个 是空集，O（1）操作，直接返回 false；否则，n 可能是大于等于 1 并小于等于 另一个 . Count 的任意值，直到找到共有元素为止，最坏的情况是检索到 另一个 的最后一个元素。

RemoveWhere

从 HashSet < T > 中移除所有与指定谓词定义的条件相匹配的元素。
public int RemoveWhere ( Predicate < T > 匹配 );

参数

返回值

异常

备注

匹配 不得修改 HashSet < T >。这样做可能会导致意外结果。

调用此方法是一个 O（n）操作，其中 n 为 HasheSet . Count。

SetEquals

确定当前的 HashSet < T > 对象和指定的集或集合是否包含相同的元素。
public bool SetEquals ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

返回值

实现

SetEquals ( IENumable < T > )

异常

备注

此方法忽略 另一个 中元素的顺序和任何重复元素。即 另一个 是集，集中的重复元素、元素顺序无关此方法的返回结果。

该方法等同于数学概念上的 A = B（忽略重复元素）。

如果由 另一个 表示的集合是与当前 HashSet < T > 对象具有相同相等比较器的 HashSet < T > 集合，则此方法是一个 O（n）操作。否则，此方法是一个O（n + m）操作，其中 n 是 另一个 . Count，m 是 HashSet . Count。

SymmetricExceptWith

修改当前的 HashSet < T > 对象，使其仅包含存在于当前对象中或指定集合中，但不同时存在于两者中的元素（即对称差集）。
public void SymmetricExceptWith ( System . Collections . Generic . IEnumerable < T > 另一个 );

参数

实现

SymmetricExceptWith ( IEnumerable < T > )

异常

备注

另一个 中的任何重复元素都会被忽略。

A . SymmetricExceptWith ( B ) 之后，A 将保留属于 A 但不属于 B 的元素，移除既属于 A 且属于 B 的元素，添加属于 B 但不属于 A 的元素。即数学上的 A △ B，或 (A - B) ∪ (B - A)。

如果 另一个 参数是与当前 HashSet < T > 对象具有相同相等比较器的 HashSet < T > 集合，则此方法是一个 O（n）操作。否则，此方法是一个 O（n + m）操作，其中 n 是 另一个 . Count，m 是 HashSet . Count。

TrimExcess

重载

public void TrimExcess ( );
public void TrimExcess ( int 容量 );

参数

异常

TryGetAlternateLookup

获取一个类型的实例，该实例可用于使用 T替代 而非 T 对当前的 HashSet < T > 执行操作。
public bool TryGetAlternateLookup < T替代 > ( out System . Collections . Generic . HashSet < T > . AlternateLookup < T替代 > 搜索 ) where TAlternate : allows ref struct;

参数

返回值

备注

该集合必须使用一个比较器，该比较器实现带有 T替代 和 T 的 IAlternateEqualityComparer < T替代 , T >。如果不这样做，该方法将返回 false。

TryGetValue

在集合中搜索给定值，如果找到相等的值，则输出该值。
public bool TryGetValue ( T 搜索值 , out T 输出值 );

参数

返回值

备注

当您的 HashSet 是引用类型（string、class 等），想要重复使用以前存储的引用而不是新构建的引用（以便可以发生更多引用共享）或查找比当前值具有更完整数据的值时，这可能很有用，尽管它们的比较器函数表明它们是相等的。但对于值类型（int、struct 等），输出值 是 搜索到的值 的副本（或者默认值），只能表示该值是否存在于 HashSet 中，倒不如使用 Contains 方法。

当 搜索值 即为 T 类型的默认值，例如在 int HashSet 中搜索 0，返回值为 true，输出值是 0，表示搜索到 0；否则，没有搜索到该值，但输出值依然是 0。无论搜索什么值，不要以 输出值 的内容判断该值是否存在，必须由该方法的返回值确定。

UnionWith

修改当前的 HashSet < T > 对象，使其包含当前对象和指定集或集合中存在的所有元素。
public void UnionWith ( System . Collections . Generic . IEnumerable < T > 另一个);

参数

实现

UnionWith ( IEnumerable < T > )

异常

备注

另一个（如果是集）中的任何重复元素都会被忽略。该方法即数学中的并集（A ∪ B）。