用于共享大型不可变对象的工厂/缓存策略

我的问题很像上一篇文章最佳哈希集初始化 (Scala | Java) https://stackoverflow.com/questions/14714900/optimal-hashset-initialization-scala-java，我想用的地方HashSet为了加速（目前我正在使用Set）但是HashSet没有表现出它的（恒定时间）优势。

对于提到的解决方案：

您可以通过实习来最大限度地降低平等成本。这意味着你 通过工厂方法获取类的新对象，该方法 检查请求的新对象是否已经存在，如果存在， 返回对现有对象的引用。如果你断言每个 这种类型的对象是以这种方式构造的，你知道有 每个不同对象和等于的只有一个实例 相当于对象标识，这是一种廉价的引用比较 （Scala 中的等式）。

但是，我不太确定检查的有效方法是什么

请求的新对象是否已经存在

对于大型对象（例如带有 hashmap 参数的 case 类对象、一些其他对象结构...等）

通过比较每个复杂的字段并不会带来太多的性能优势，不是吗？或者如果是的话还有其他方法吗？

另外，我也很困惑如何制作

等于变成 相当于对象标识，这是一种廉价的引用比较 （Scala 中的等式）。

in code.

我认为，上面提到的意图技术基本上是一种对象缓存。 因此，我参考了帖子中提到的技术Java中小型不可变对象的缓存策略？ https://stackoverflow.com/questions/5783839/caching-strategy-for-small-immutable-objects-in-java。但是，我仍然不知道对于大型对象有什么有效的方法。

为了方便起见，我引用了帖子中的缓存技术（Java）///表示我的想法和问题：

private static final int N_POINTS = 10191; 
private static final Point[] POINTS = new Point[N_POINTS];

public static Point of(int x, int y, int z) {
    int h = hash(x,y,z); ///  I can use hash code of each complicated field to construct the value
    int index = (h & 0x7fffffff) % N_POINTS;
    Point p = POINTS[index];
    if (p != null && p.x == x && p.y == y && p.z == z) /// Not working for large objects?
       return p;
    return POINTS[index] = new Point(x,y,z);
} 

总而言之，对大对象实施高效缓存策略的最佳实践是什么，以便我可以利用HashSet在斯卡拉？

Thanks,

实习的目标是使equals要实现的方法使用引用相等 as: this eq that (or this == that在爪哇）。 很明显，该实现将具有最佳的运行时特性 越多传统的 equals比较一些字段集。

仅当存在且仅有一个实例时，此比较才有效 每个“唯一对象”由对象的某些字段集确定。

Intern-ing 仅在以下情况下有效 的前期成本intern手术 可以通过（可能很多）调用的最小化成本来完全抵消equals, 通过驱动HashMap.

正如您所指出的，这intern-ing 可能需要一个潜在昂贵的缓存机制： 有运行时开销（执行检查） 和内存开销（缓存的大小）。

• 最直接的缓存方法是HashMap，以及传统的equals. hashCode应该偷懒；缓存其结果，因此不需要重新计算。 可能需要考虑线程问题。

• 实现这种缓存的一种方法是使用trie http://en.wikipedia.org/wiki/Trie，也许在每个节点处用哈希表实现，并且其中每个“级别”对应于对象中的一个字段（第一级别 - 字段 1、第二级别、字段 2 等...），用于“用于的字段集”建立独特性。”

还有其他可行的方法来实现这种缓存。 请原谅我避免进一步讨论此类问题， 请允许我提出一些避免处理该问题的方法。

选项 1：不缓存

Claim: 您可能会获得足够有效的结果 使用快速哈希（并在内部缓存）， 的“传统”实现equals, 并从一个开始HashMap or HashSet of 足够的最小尺寸 https://stackoverflow.com/questions/1324064/performance-of-hashmap-with-different-initial-capacity-and-load-factor

理想情况下，哈希表中很少有冲突， 以及拨打电话的次数equals是最小的。

选项 2：将多个字段映射到一个唯一字段String

[此方法假设“唯一定义对象的字段”是不可变的。如果情况并非如此，可以进行适当的调整来补偿。]

构建并缓存private unique: String对应于唯一的对象实例。 例如，对于某些简单对象，以下内容可能是唯一的：

“用于建立唯一性的字段集”的字符串值的串联，以逗号分隔。

了解您的物体/场特征将有助于确定 如何创建这样一个独特的字符串。

有了这样的值，我们就可以避免单独的实习生/缓存机制 并通过实施两者保留大部分好处equals and hashCode就这一点而言unique string:

def equals(thatObj: Any) = thatObj match {
    case that : MyType => unique.equals(that.unique)
    case _             => false
  }

def hashCode() = unique.hashCode

选项 2 的替代方案：

[编辑：Rüdiger Klaehn 提供此链接提供了避免 String.intern() 的令人信服的证据 https://stackoverflow.com/questions/10624232/performance-penalty-of-string-intern]

Use String.intern并调整equals利用它：

private val unique = buildUnique().intern

def equals(thatObj: Any) = thatObj match {
    case that : MyType => unique.eq(that.unique) // In Java: unique == that.unique
    case _             => false
  }