为什么我不能在没有枚举的情况下从 HashSet 中检索项目？

Question

我正在寻找 HashSet 设计者的头脑。据我所知，我的问题同时适用于 Java 和 C# HashSet，这让我觉得这一定是有充分理由的，尽管我自己也想不出来。

我在HashSet中插入了一个item后，为什么不枚举就无法检索到那个item，几乎不是一个高效的操作？特别是因为 HashSet 是以一种支持高效检索的方式显式构建的。

让 Remove(x) 和 Contains(x) 返回被删除或包含的实际项目通常对我很有用。这不一定是我传递给 Remove(x) 或 Contains(x) 函数的项目。当然，我想我可以通过 HashMap 实现相同的效果，但是当完全可以使用集合来实现这一点时，为什么还要浪费所有的空间和精力呢？

我理解可能存在一些设计问题，即添加此功能将允许使用与其在框架中的角色或未来角色不一致的 HashSet，但如果是这样，这些设计问题是什么？

编辑

要回答更多问题，这里有更多详细信息：

我在 C# 中使用具有覆盖哈希码、equals 等的不可变引用类型来模拟值类型。假设该类型具有成员 A、B 和 C。Hashcode、equals 等仅取决于 A 和 B。给定一些 A 和 B，我希望能够从哈希集中检索该等价项并得到它的 C。我赢了似乎无法为此使用 HashSet，但我至少想知道这是否有任何充分的理由。伪代码如下：

public sealed class X{
 object A;
 object B;
 object extra;

 public int HashCode(){
  return A.hashCode() + B.hashCode();
 }

 public bool Equals(X obj){
  return obj.A == A && obj.B == B;
 }
}

hashset.insert(new X(1,2, extra1));
hashset.contains(new X(1,2)); //returns true, but I can't retrieve extra

Answer 1

在 .Net 中，您可能正在寻找的是 KeyedCollection http://msdn.microsoft.com/en-us/library/ms132438.aspx

您可以通过一些“通用”的聪明才智来解决每次重新实现这个抽象类的麻烦。 （参见 IKeyedObject`1。）

注意：任何实现 IKeyedObject`1 的数据传输对象都应该有一个重写的 GetHashCode 方法，只需返回 this.Key.GetHashCode();等号也一样...

我的基类库中通常会出现这样的内容：

public class KeyedCollection<TItem> : System.Collections.ObjectModel.KeyedCollection<TItem, TItem>
    where TItem : class
{
    public KeyedCollection() : base()
    {
    }

    public KeyedCollection(IEqualityComparer<TItem> comparer) : base(comparer)
    {
    }

    protected override TItem GetKeyForItem(TItem item)
    {
        return item;
    }
}

public class KeyedObjectCollection<TKey, TItem> : System.Collections.ObjectModel.KeyedCollection<TKey, TItem>
    where TItem : class, IKeyedObject<TKey>
    where TKey : struct
{
    public KeyedCollection() : base()
    {
    }

    protected override TItem GetKeyForItem(TItem item)
    {
        return item.Key;
    }
}

///<summary>
/// I almost always implement this explicitly so the only
/// classes that have access without some rigmarole
/// are generic collections built to be aware that an object
/// is keyed.
///</summary>
public interface IKeyedObject<TKey>
{
    TKey Key { get; }
}

Answer 2

您打算如何从哈希集中检索项目？根据定义，集合没有以任何方式排序，因此没有可用于检索相关对象的索引。

集合，作为一个概念，用于测试包含，即有问题的元素是否在哈希数据集中。如果您希望使用键值或索引从数据源中检索值，我建议您查看 Map 或 List。

编辑：基于对原始问题的编辑的附加答案

很快，根据您的新信息，您可能有兴趣将您的数据实现为 Java 枚举，类似于以下内容：

 public enum SoonilsDataType {
      A, B, C;

      // Just an example of what's possible
      public static SoonilsDataType getCompositeValue(SoonilsDataType item1,
           SoonilsDataType item2) {
           if (item1.equals(A) && 
                     item2.equals(B)) {
                return C;
           }
      }
 }

枚举的自动继承 values() 返回枚举的“集合”中所有值的列表，您可以使用与集合相同的方式测试包含性。此外，因为它是一个完整的类，您可以定义新的静态方法来执行复合逻辑（就像我在示例代码中试图暗示的那样）。 Enum 唯一的问题是您不能在运行时添加新实例，这可能不是您想要的（尽管如果集合的数据大小不会在运行时增长，Enum 就是您想要的）。

Answer 3

如果您在插入对象后更改它，则它的哈希可能已更改（如果 hashCode() 已被覆盖，则尤其可能发生这种情况）。如果散列发生变化，则在集合中查找它会失败，因为您将尝试查找散列在与存储位置不同的位置的对象。

此外，如果要查找不同实例的相等对象，则需要确保已在对象中覆盖了 hashCode 和 equals。

请注意，这一切都适用于 Java - 我假设 C# 也有类似的东西，但由于我使用 C# 已经有好几年了，我会让其他人谈谈它的功能。

Answer 4

我想Set 接口和HashSet 类的设计者希望确保Collection 接口上定义的remove(Object) 方法也适用于Set；此方法返回一个布尔值，表示对象是否已成功删除。如果设计者想要提供 remove(Object) 返回 Set 中已经存在的“相等”对象的功能，这将意味着不同的方法签名。

此外，鉴于被删除的对象在逻辑上等于传递给 remove(Object) 的对象，因此在返回包含的对象时添加的值是有争议的。但是，我自己之前也遇到过这个问题，并且使用了 Map 来解决问题。

请注意，在 Java 中，HashSet 在内部使用HashMap，因此使用HashMap 不会产生额外的存储开销。

Answer 5

为什么不直接使用HashMap<X,X>？这正是你想要的。每次只需执行.put(x,x)，然后您就可以使用.get(x) 获取等于x 的存储元素。

Answer 6

这是图书馆设计师的疏忽。正如我在another answer 中提到的，此方法已添加到.NET Framework 4.7.2（以及之前的.NET Core 2.0）；见HashSet<T>.TryGetValue。引用the source：

/// <summary>
/// Searches the set for a given value and returns the equal value it finds, if any.
/// </summary>
/// <param name="equalValue">The value to search for.
/// </param>
/// <param name="actualValue">
/// The value from the set that the search found, or the default value
/// of <typeparamref name="T"/> when the search yielded no match.</param>
/// <returns>A value indicating whether the search was successful.</returns>
/// <remarks>
/// This can be useful when you want to reuse a previously stored reference instead of 
/// a newly constructed one (so that more sharing of references can occur) or to look up
/// a value that has more complete data than the value you currently have, although their
/// comparer functions indicate they are equal.
/// </remarks>
public bool TryGetValue(T equalValue, out T actualValue)

Answer 7

在我看来，您实际上是在寻找 Map<X,Y>，其中 Y 是 extra1 的类型。

---

（下面是咆哮）

equals 和 hashCode 方法定义了有意义的对象相等性。 HashSet 类假定如果两个对象相等，如Object.equals(Object) 所定义，那么这两个对象之间没有区别。

我想说的是，如果object extra 有意义，那么您的设计并不理想。

Answer 8

已解决。希望找到一个元素对我来说似乎完全有效，因为用于搜索的代表可能与找到的元素不同。如果元素包含键和值信息，并且自定义相等比较器仅比较键部分，则尤其如此。请参阅代码示例。该代码包含一个比较器，该比较器实现了自定义搜索和，用于捕获找到的元素。这需要一个比较器的实例。清除对找到的元素的引用。通过包含执行搜索。访问找到的元素。共享比较器实例时要注意多线程问题。

using System;
using System.Collections.Generic;

namespace ConsoleApplication1 {

class Box
{
    public int Id;
    public string Name;
    public Box(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

class BoxEq: IEqualityComparer<Box>
{
    public Box Element;

    public bool Equals(Box element, Box representative)
    {
        bool found = element.Id == representative.Id;
        if (found)
        {
            Element = element;
        }
        return found;
    }

    public int GetHashCode(Box box)
    {
        return box.Id.GetHashCode();
    }
}

class Program
{
    static void Main()
    {
        var boxEq = new BoxEq();
        var hashSet = new HashSet<Box>(boxEq);
        hashSet.Add(new Box(3, "Element 3"));
        var box5 = new Box(5, "Element 5");
        hashSet.Add(box5);
        var representative = new Box(5, "Representative 5");
        boxEq.Element = null;
        Console.WriteLine("Contains {0}: {1}", representative.Id, hashSet.Contains(representative));
        Console.WriteLine("Found id: {0}, name: {1}", boxEq.Element.Id, boxEq.Element.Name);
        Console.WriteLine("Press enter");
        Console.ReadLine();
    }
}

} // namespace

Answer 9

那些语言中的集合对象大多被设计为值集合，而不是可变对象。他们使用等号检查放入其中的对象是否唯一。这就是为什么 contains 和 remove 返回布尔值，而不是对象：它们检查或删除您传递给它们的值。

实际上，如果您对集合执行 contains(X)，并期望得到不同的对象 Y，这意味着 X 和 Y 相等（即 X.equals(Y) => true），但有点不同，这似乎是错误的。

Answer 10

我收到了一个关于使用 Map 的有趣建议，方法是让我自己的对象将自己定义为 KeyValuePairs。虽然是一个很好的概念，但不幸的是 KeyValuePair 不是一个接口（为什么不呢？），而是一个结构，它把这个计划从空中发射出去。最后我会推出我自己的 Set，因为我的约束允许我有这个选项。

Answer 11

简答；因为这些项目不能保证是不可变的。

我遇到了您描述的确切问题，其中 HashCode 基于成员类中的固定字段，但该类包含可以在不更改哈希的情况下更新的附加信息。

我的解决方案是实现一个基于 ICollection 的通用 MyHashSet，但包裹在 Dictionary> 以提供所需的查找效率，其中 int 键是 T 的 HashCode。但是，这表明如果成员对象的 HashCode 可以更改，那么字典查找后跟列表中项目的相等比较将永远找不到更改的项目。没有强制成员不可变的机制，因此唯一的解决方案是枚举批次。

Answer 12

在想同样的事情之后，并且能够很好地查看源代码：

来源：http://referencesource.microsoft.com/#System.Core/System/Collections/Generic/HashSet.cs

集合是唯一项（对象或值）的集合。在 .net 实现中，如果比较器的 Equals 方法为这两个项目返回 true，则该项目与另一个项目相同（不是唯一的）。如果这两个项目具有相同的哈希码，则不会。因此，检查项目是否存在是一个两步过程。首先使用 hashset 来最小化要完成的项目的数量，然后是压缩本身。

如果您希望检索一个项目，您必须能够为检索函数提供一个唯一标识符。你可能知道你想要的项目的哈希码。但这还不够。因为多个项目可以具有相同的哈希值。您还需要提供项目本身，以便可以调用 Equal 方法。很明显，如果您拥有该物品，就没有理由得到它。

可以创建一个数据结构，要求没有两个唯一项返回相同的哈希码。而不是你可以从中得到一个项目。添加*会更快，如果您知道哈希，则可以检索。如果将两个不相等但返回相同哈希的项目放入其中，则第一个将被覆盖。据我所知，这种类型在 .net 中不存在，不，这与字典不同。

*假设 GetHash 方法是相同的。