java不变map

HashMap使用hashCode()，==并equals()用于条目查找。给定键的查找序列k如下：

使用k.hashCode()来确定条目存储其斗，如果有的话

如果找到，对于k1该桶中的每个条目的密钥，如果k == k1 || k.equals(k1)，则返回k1的条目

任何其他结果，没有相应的条目

为了演示一个例子，假设我们想要创建一个HashMapwhere键，如果它们具有相同的整数值(由AmbiguousIntegerclass 表示)，则它们在逻辑上是等价的。然后我们构造一个HashMap，放入一个条目，然后尝试覆盖其值并按键检索值。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
}
HashMap map = new HashMap<>();
// logically equivalent keys
AmbiguousInteger key1 = new AmbiguousInteger(1),
key2 = new AmbiguousInteger(1),
key3 = new AmbiguousInteger(1);
map.put(key1, 1); // put in value for entry '1'
map.put(key2, 2); // attempt to override value for entry '1'
System.out.println(map.get(key1));
System.out.println(map.get(key2));
System.out.println(map.get(key3));
Expected: 2, 2, 2

不要覆盖hashCode()和equals()：在默认情况下的Java生成不同的hashCode()不同对象的值，因此HashMap使用这些值映射key1和key2成不同的桶。key3没有相应的桶，所以它没有价值。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 2, set as entry 2[1]
map.get(key1); // map to bucket 1, get as entry 1[1]
map.get(key2); // map to bucket 2, get as entry 2[1]
map.get(key3); // map to no bucket
Expected: 2, 2, 2
Output:   1, 2, null

hashCode()仅覆盖： HashMap映射key1并key2进入同一个存储桶，但由于两者key1 == key2和key1.equals(key2)检查失败，它们保持不同的条目，因为默认情况下equals()使用==check，它们引用不同的实例。key3失败都==和equals()检查对key1和key2，因此具有没有对应的值。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
@Override
public int hashCode() {
return value;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 1, set as entry 1[2]
map.get(key1); // map to bucket 1, get as entry 1[1]
map.get(key2); // map to bucket 1, get as entry 1[2]
map.get(key3); // map to bucket 1, no corresponding entry
Expected: 2, 2, 2
Output:   1, 2, null

equals()仅覆盖： HashMap由于默认值不同，将所有密钥映射到不同的存储桶hashCode()。==或者equals()检查在这里是无关紧要的，因为它HashMap永远不会达到需要使用它们的程度。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
@Override
public boolean equals(Object obj) {
return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 2, set as entry 2[1]
map.get(key1); // map to bucket 1, get as entry 1[1]
map.get(key2); // map to bucket 2, get as entry 2[1]
map.get(key3); // map to no bucket
Expected: 2, 2, 2
Actual:   1, 2, null

覆盖both hashCode()和equals()：HashMapmaps key1，key2并覆盖key3到同一个存储桶中。==在比较不同的实例时检查失败，但是equals()检查通过，因为它们都具有相同的值，并且被我们的逻辑视为“逻辑上等效”。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
@Override
public int hashCode() {
return value;
}
@Override
public boolean equals(Object obj) {
return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 1, set as entry 1[1], override value
map.get(key1); // map to bucket 1, get as entry 1[1]
map.get(key2); // map to bucket 1, get as entry 1[1]
map.get(key3); // map to bucket 1, get as entry 1[1]
Expected: 2, 2, 2
Actual:   2, 2, 2

如果hashCode()随机怎么办？：HashMap将为每个操作分配一个不同的存储桶，因此您永远不会找到您之前输入的相同条目。

class AmbiguousInteger {
private static int staticInt;
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
@Override
public int hashCode() {
return ++staticInt; // every subsequent call gets different value
}
@Override
public boolean equals(Object obj) {
return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 2, set as entry 2[1]
map.get(key1); // map to no bucket, no corresponding value
map.get(key2); // map to no bucket, no corresponding value
map.get(key3); // map to no bucket, no corresponding value
Expected: 2, 2, 2
Actual:   null, null, null

如果hashCode()总是一样的话怎么办？：HashMap将所有键映射到一个大桶中。在这种情况下，您的代码在功能上是正确的，但使用HashMap实际上是多余的，因为任何检索都需要在O(N)时间内迭代该单个存储桶中的所有条目(或Java 8的O(logN))，等效使用a List。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
@Override
public int hashCode() {
return 0;
}
@Override
public boolean equals(Object obj) {
return obj instanceof AmbiguousInteger && value == ((AmbiguousInteger) obj).value;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 1, set as entry 1[1]
map.get(key1); // map to bucket 1, get as entry 1[1]
map.get(key2); // map to bucket 1, get as entry 1[1]
map.get(key3); // map to bucket 1, get as entry 1[1]
Expected: 2, 2, 2
Actual:   2, 2, 2

如果equals总是假的怎么办？：==当我们将同一个实例与自身进行比较时检查通过，但是否则失败，equals检查总是失败key1，key2并且key3被认为是“逻辑上不同”，并且映射到不同的条目，尽管它们仍然在同一桶中hashCode()。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
@Override
public int hashCode() {
return 0;
}
@Override
public boolean equals(Object obj) {
return false;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 1, set as entry 1[2]
map.get(key1); // map to bucket 1, get as entry 1[1]
map.get(key2); // map to bucket 1, get as entry 1[2]
map.get(key3); // map to bucket 1, no corresponding entry
Expected: 2, 2, 2
Actual:   1, 2, null

好的，如果equals现在总是如此？：你基本上是说所有对象都被认为与另一个对象“在逻辑上等同”，所以它们都映射到同一个桶(由于相同hashCode())，相同的条目。

class AmbiguousInteger {
private final int value;
AmbiguousInteger(int value) {
this.value = value;
}
@Override
public int hashCode() {
return 0;
}
@Override
public boolean equals(Object obj) {
return true;
}
}
map.put(key1, 1); // map to bucket 1, set as entry 1[1]
map.put(key2, 2); // map to bucket 1, set as entry 1[1], override value
map.put(new AmbiguousInteger(100), 100); // map to bucket 1, set as entry1[1], override value
map.get(key1); // map to bucket 1, get as entry 1[1]
map.get(key2); // map to bucket 1, get as entry 1[1]
map.get(key3); // map to bucket 1, get as entry 1[1]
Expected: 2, 2, 2
Actual:   100, 100, 100