3 
public class HashMapKeySet {

public static void main(String[] args) {
    Map<HashCodeSame,Boolean> map=new HashMap();

    map.put(new HashCodeSame(10),true);
    map.put(new HashCodeSame(2),false);

    for(HashCodeSame i:map.keySet())
        System.out.println("Key: "+i+"\t Key Value: "+i.getA()+"\t Value: "+map.get(i)+"\t Hashcode: "+i
                .hashCode());

    System.out.println("\nEntry Set******");
    for(Map.Entry<HashCodeSame, Boolean> i:map.entrySet())
        System.out.println("Key: "+i.getKey().getA()+"\t Value: "+i.getValue()+"\t Hashcode: "+i.hashCode());

    System.out.println("\nValues******");
    for(Boolean i:map.values())
        System.out.println("Key: "+i+"\t Value: "+map.get(i)+"\t Hashcode: "+i.hashCode());

}

static class HashCodeSame{

    private int a;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    HashCodeSame(int a){
        this.a=a;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        HashCodeSame that = (HashCodeSame) o;

        return a == that.a;

    }

    @Override
    public int hashCode() {
        return 1;
    }
}

}

如果您可以在上面的示例中看到，我已经明确地让 hashcode() 在所有情况下都返回 1，以检查当 hashmap 中 key.hashcode() 发生冲突时会发生什么。会发生什么，为这些 Map.Entry 对象维护一个链表，例如

1(key.hashcode()) 将链接到 <2,false> 将链接到 <10,true>

（据我了解，在真值之后输入假值）。

但是当我执行 keySet() 时，先返回 true，然后返回 false，而不是先返回 false。

所以，我在这里假设，因为 keySet() 是一个集合并且集合保持顺序，我们在迭代时得到真假。但是，话又说回来，我们为什么不说 hashmap 保持顺序，因为检索的唯一方法是按顺序。或者为什么我们使用 LinkedHashMap？

 Key: DS.HashMapKeySet$HashCodeSame@1    Key Value: 10   Value: true     Hashcode: 1
Key: DS.HashMapKeySet$HashCodeSame@1     Key Value: 2    Value: false    Hashcode: 1

Entry Set******
Key: 10  Value: true     Hashcode: 1230
Key: 2   Value: false    Hashcode: 1236

Values******
Key: true    Value: null     Hashcode: 1231
Key: false   Value: null     Hashcode: 1237

现在，当我添加 chsnge 时，hashcode 方法返回一个like

@Override
    public int hashCode() {
        return a;
    }

我得到相反的顺序。加上加上

    map.put(new HashCodeSame(10),true);
    map.put(new HashCodeSame(2),false);
    map.put(new HashCodeSame(7),false);
    map.put(new HashCodeSame(3),true);
    map.put(new HashCodeSame(9),true);

收到的输出是，

    Key: DS.HashMapKeySet$HashCodeSame@2     Key Value: 2    Value: false    Hashcode: 2
Key: DS.HashMapKeySet$HashCodeSame@3     Key Value: 3    Value: false    Hashcode: 3
Key: DS.HashMapKeySet$HashCodeSame@7     Key Value: 7    Value: false    Hashcode: 7
Key: DS.HashMapKeySet$HashCodeSame@9     Key Value: 9    Value: true     Hashcode: 9
Key: DS.HashMapKeySet$HashCodeSame@a     Key Value: 10   Value: true     Hashcode: 10

Entry Set******
Key: 2   Value: false    Hashcode: 1239
Key: 3   Value: false    Hashcode: 1238
Key: 7   Value: false    Hashcode: 1234
Key: 9   Value: true     Hashcode: 1222
Key: 10  Value: true     Hashcode: 1221

Values******
Key: false   Value: null     Hashcode: 1237
Key: false   Value: null     Hashcode: 1237
Key: false   Value: null     Hashcode: 1237
Key: true    Value: null     Hashcode: 1231
Key: true    Value: null     Hashcode: 1231

现在它再次让我想知道，为什么订单是以排序方式出现的。？谁能详细解释一下 hashmap 的 keySet()、entrySet() 方法是如何工作的？

4

2 回答 2

6

HashMap 没有定义的迭代顺序，LinkedHashMap 但有指定的迭代顺序。

困难HashMap在于构建简单的例子很容易，其中迭代顺序是相当可预测的并且相当稳定，即使这不能保证。

例如，假设您这样做了：

    Map<String, Boolean> map = new HashMap<>();
    String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    for (int i = 0; i < str.length(); i++) {
        map.put(str.substring(i, i+1), true);
    }
    System.out.println(map.keySet());

结果是

[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]

嘿！那些是有序的！嗯，原因是 String 的 hashCode() 函数非常糟糕，而且对于单字符串来说特别糟糕。这是 String 的hashCode() 规范。本质上它是一个相乘，但对于一个单字符的字符串，它只是那个的 Unicode 值char。所以上面的单个字符串的哈希码是 65, 66, ... 90。 的内部表HashMap总是 2 的幂，在这种情况下它有 64 个条目长。使用的表条目是键的hashCode()值右移 16 位并与自身进行异或，以表大小为模。（请参见此处的代码。）因此，这些单字符串最终出现在HashMap表中的顺序存储桶中，位于数组位置 1、2、... 26 中。

密钥迭代通过桶按顺序进行，因此密钥最终以它们被放入的顺序出现。同样，这不能保证，由于各种实现的特性，它恰好以这种方式工作如上所述。

现在考虑函数每次返回 1HashCodeSame的位置。hashCode()将这些对象中的一些添加到 aHashMap将导致它们最终都在同一个存储桶中，并且由于迭代按顺序遍历链表，它们将按顺序出现：

    Map<HashCodeSame, Boolean> map = new HashMap<>();
    for (int i = 0; i < 8; i++) {
        map.put(new HashCodeSame(i), true);
    }
    System.out.println(map.keySet());

（我添加了一个toString()做显而易见的事情的方法。）结果是：

[HCS(0), HCS(1), HCS(2), HCS(3), HCS(4), HCS(5), HCS(6), HCS(7)]

同样，由于实现的巧合，密钥按顺序出现，但原因与上述不同。

可是等等！在 JDK 8 中，HashMap如果同一桶中出现太多条目，则将桶从线性链表转换为平衡树。如果超过 8 个条目最终位于同一个存储桶中，则会发生这种情况。让我们试试：

    Map<HashCodeSame, Boolean> map = new HashMap<>();
    for (int i = 0; i < 20; i++) {
        map.put(new HashCodeSame(i), true);
    }
    System.out.println(map.keySet());

结果是：

[HCS(5), HCS(0), HCS(1), HCS(2), HCS(3), HCS(4), HCS(6),
HCS(18), HCS(7), HCS(11), HCS(16), HCS(17), HCS(15), HCS(13),
HCS(14), HCS(8), HCS(12), HCS(9), HCS(10), HCS(19)]

底线是HashMap不维护定义的迭代顺序。如果你想要一个特定的迭代顺序，你必须使用LinkedHashMap或排序的映射，例如TreeMap. 不幸的是，HashMap它有一个相当稳定和可预测的迭代顺序，事实上，它的可预测性足以让人们认为它的顺序是明确定义的，而实际上并非如此。

为了帮助解决这个问题，在 JDK 9 中，新的基于散列的集合实现将随机化它们从运行到运行的迭代顺序。例如：

    Set<String> set = Set.of("A", "B", "C", "D", "E",
                             "F", "G", "H", "I", "J");
    System.out.println(set);

当在 JVM 的不同调用中运行时，这会打印出以下内容：

[I, H, J, A, C, B, E, D, G, F]
[C, B, A, G, F, E, D, J, I, H]
[A, B, C, H, I, J, D, E, F, G]

（迭代顺序在 JVM 的单次运行中是稳定的。此外，现有的集合，例如HashMap没有随机化的迭代顺序。）

于 2016-06-10T20:33:32.677 回答
0

在 Java doc for LinkedHashMap中回答您的问题

Map 接口的哈希表和链表实现，具有可预测的迭代顺序。此实现与 HashMap 的不同之处在于它维护一个双向链表，该列表贯穿其所有条目。这个链表定义了迭代顺序，通常是键插入映射的顺序（插入顺序）。请注意，如果将键重新插入到地图中，则插入顺序不会受到影响。（如果在调用 m.containsKey(k) 将在调用之前立即返回 true 时调用 m.put(k, v)，则将键 k 重新插入到映射 m 中。）

此实现使其客户免于 HashMap（和 Hashtable）提供的未指定的、通常是混乱的排序，而不会增加与 TreeMap 相关的成本。无论原始地图的实现如何，它都可用于生成与原始地图具有相同顺序的地图副本：

 void foo(Map m) {
     Map copy = new LinkedHashMap(m);
     ...
 }
于 2016-06-10T09:43:17.643 回答