Java-Hashmap检索序列 import java.util.HashMap； 导入java.util.Map.Entry； 公共类测试字符串{ 公共静态void main（字符串[]args）{ gc（）； String str=“deepak”； int length=str.length（）； System.out.println（“str”+str+“长度”+length）； HashMap=newHashMap（）； 对于（int i=0；i>112键：p

hashcode 96密钥的hashcode>>97密钥：a

hashcode 101密钥的hashcode>>100密钥：d

hashcode 103键的hashcode>>101键：e

hashcode 106密钥的hashcode>>107密钥：k

>

{p=1，a=1，d=1，e=2，k=1}

有人能帮我理解程序和输出中的两件事吗

地图对象打印的数据，内部如何决定顺序？ 这是打印顺序p、a、d、e、k

entry.hashcode（）和entry.key（）.hashcode（）有什么区别？ 请参考输出以解释差异

据我所知，HashMap并不是按照入口或键的顺序排列的。如果你想对它们进行排序，你需要一个树映射或链接映射。HashMap根本没有顺序

我已经向您注释了指向的链接，这很好地解释了它。但我将根据您的输出进行解释：

hashcode 113密钥的hashcode>>112密钥：p

这意味着：条目HashCode是113。密钥的HashCode是112。您不打印条目的HashCode，它是1。条目的HashCode是用密钥的HashCode和值的HashCode计算的。那些到HashCode的值将被异或

据我所知，HashMap并不是按照入口或键的顺序排列的。如果你想对它们进行排序，你需要一个树映射或链接映射。HashMap根本没有顺序

我已经向您注释了指向的链接，这很好地解释了它。但我将根据您的输出进行解释：

hashcode 113密钥的hashcode>>112密钥：p

---

这意味着：条目HashCode是113。密钥的HashCode是112。您不打印条目的HashCode，它是1。条目的HashCode是用密钥的HashCode和值的HashCode计算出来的。这些HashCode将被XORD。

迭代顺序是未指定的，从技术上讲，它是一个函数关键哈希代码、实际映射实现、映射的容量，以及在某些情况下特定映射实例的历史记录

通过将代码更改为，可以轻松地显示对映射容量的依赖关系

import java.util.HashMap;
import java.util.Map.Entry;
public class TestString {
    public static void main(String[] args) {
        System.gc();

        String str = "deepak";
        int length = str.length();
        System.out.println("str " + str + " length " + length);

        HashMap<Character,Integer> map = new HashMap<Character,Integer>();
        for(int i=0; i<length; i++){
            char ch = str.charAt(i);
            if(map.containsKey(ch)){
                Integer val = map.get(ch);
                map.put(ch, val+1);
            }else{
                map.put(ch, 1);
            }
        }

        for (Entry<Character, Integer> entry : map.entrySet())
        {
            int hashCode = entry.hashCode();
            char key = entry.getKey();
           // int hash = hash();
            System.out.println("hashcode  " + hashCode + " hashcode of key>> " + entry.getKey().hashCode() + " key : " + key);
        }
        System.out.println(">>> " + map);
    }
}

显示具有不同容量的映射如何显示不同的迭代顺序

---

键和

Map.Entry

实例是不同的对象，因此它们具有不同的哈希代码也就不足为奇了

映射条目e的哈希代码定义为：

String str = "deepak";
int length = str.length();
System.out.println("str " + str + " length " + length);

HashMap<Character,Integer> map = new HashMap<>(100);
for(int i=0; i<length; i++) {
    char ch = str.charAt(i);
    map.merge(ch, 1, Integer::sum);
}

for(Entry<Character, Integer> entry: map.entrySet()) {
    int hashCode = entry.hashCode();
    Character key = entry.getKey();
    System.out.printf("hashcode %3d, hashcode of key %3d, key : %s%n",
                      hashCode, key.hashCode(), key);
}
map = new HashMap<>(map);
System.out.println(">>> " + map);

这确保了

e1.equals（e2）

意味着

e1.hashCode（）==e2.hashCode（）

对于任何两个条目

e1

和

e2

，这是

Object.hashCode

的总合同所要求的

这与

Map

视图的预期行为一致。如果有两个

Map

s、

a

和

b

，则

• a.keySet（）.equals（b.keySet（））

  将在两个贴图具有相同键时为真

• a.entrySet（）.equals（b.entrySet（））

  将为真，前提是两个映射具有相同的键，并且每个键映射到每个映射的相同值，换句话说，两个映射都是相等的
  这甚至是：
  如果给定对象也是一个映射并且两个映射表示相同的映射，则返回

  true

  。更正式地说，如果

  m1.entrySet（）.equals（m2.entrySet（））

  ，则两个映射

  m1

  和

  m2

  表示相同的映射

• 由于键和条目是不同的东西，

  a.keySet（）.equals（a.entrySet（））

  只能在

  a

  为空时为真

---

迭代顺序是未指定的，从技术上讲，它是对关键哈希代码、实际映射实现、映射容量以及某些情况下特定映射实例历史的函数

通过将代码更改为，可以轻松地显示对映射容量的依赖关系

import java.util.HashMap;
import java.util.Map.Entry;
public class TestString {
    public static void main(String[] args) {
        System.gc();

        String str = "deepak";
        int length = str.length();
        System.out.println("str " + str + " length " + length);

        HashMap<Character,Integer> map = new HashMap<Character,Integer>();
        for(int i=0; i<length; i++){
            char ch = str.charAt(i);
            if(map.containsKey(ch)){
                Integer val = map.get(ch);
                map.put(ch, val+1);
            }else{
                map.put(ch, 1);
            }
        }

        for (Entry<Character, Integer> entry : map.entrySet())
        {
            int hashCode = entry.hashCode();
            char key = entry.getKey();
           // int hash = hash();
            System.out.println("hashcode  " + hashCode + " hashcode of key>> " + entry.getKey().hashCode() + " key : " + key);
        }
        System.out.println(">>> " + map);
    }
}

显示具有不同容量的映射如何显示不同的迭代顺序

---

键和

Map.Entry

实例是不同的对象，因此它们具有不同的哈希代码也就不足为奇了

映射条目e的哈希代码定义为：

String str = "deepak";
int length = str.length();
System.out.println("str " + str + " length " + length);

HashMap<Character,Integer> map = new HashMap<>(100);
for(int i=0; i<length; i++) {
    char ch = str.charAt(i);
    map.merge(ch, 1, Integer::sum);
}

for(Entry<Character, Integer> entry: map.entrySet()) {
    int hashCode = entry.hashCode();
    Character key = entry.getKey();
    System.out.printf("hashcode %3d, hashcode of key %3d, key : %s%n",
                      hashCode, key.hashCode(), key);
}
map = new HashMap<>(map);
System.out.println(">>> " + map);

这确保了

e1.equals（e2）

意味着

e1.hashCode（）==e2.hashCode（）

对于任何两个条目

e1

和

e2

，这是

Object.hashCode

的总合同所要求的

这与

Map

视图的预期行为一致。如果有两个

Map

s、

a

和

b

，则

• a.keySet（）.equals（b.keySet（））

  将在两个贴图具有相同键时为真

• a.entrySet（）.equals（b.entrySet（））

  将为真，前提是两个映射具有相同的键，并且每个键映射到每个映射的相同值，换句话说，两个映射都是相等的
  这甚至是：
  如果给定对象也是一个映射并且两个映射表示相同的映射，则返回

  true

  。更正式地说，如果

  m1.entrySet（）.equals（m2.entrySet（））

  ，则两个映射

  m1

  和

  m2

  表示相同的映射

• 由于键和条目是不同的东西，

  a.keySet（）.equals（a.entrySet（））

  只能在

  a

  为空时为真

---

这里有点不清楚你想证明什么或想问什么，但用一个更简单的例子怎么样

Map<String, Integer> map2 = Map.of("1", 1, "2", 2, "3", 3);
System.out.println(map2);

{1=1, 3=3, 2=2}

{1=1, 2=2, 3=3}