Java 地图放什么回来？

我尝试获取map接口的put方法的返回类型。当我第一次打印时，它打印空值，在更新密钥后，我得到上一个值。 那么，有人能告诉我map接口中put方法的返回类型是什么吗

Map<Integer, String> map = new HashMap<Integer, String>();
System.out.println(map.put(1, "ABC"));
System.out.println(map.put(1, "XYZ"));

Output:
null
ABC

Map Map=newhashmap（）；
系统输出打印LN（映射输出（1，“ABC”）；
System.out.println（map.put（1，“XYZ”）；
输出：
无效的
基础知识

根据，它是一个通用函数，返回与映射值相同的数据类型。因此，在您的情况下，它应该返回

String

此方法返回与键（如果存在）关联的上一个值，否则返回null。因此，上述情况下的返回类型为字符串。

您可以在文档中读取：

返回： 与键关联的上一个值，如果键没有映射，则为null。（null返回也可以表示映射 如果实现支持，则以前将null与键关联 空值。）

既然你的地图被声明为

Map<Integer, String> map

地图

值V是字符串类型，因此调用put将返回字符串

但我得到的价值是什么？也许你在问自己

然后深入查看源代码

HashMap的put方法实际上是调用最后一个方法putVal

其实现方式如下：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

final V putVal（int散列、K键、V值、布尔onlyfabsent、布尔逐出）{
节点[]选项卡；节点p；int n，i；
如果（（制表符=表格）=null | |（n=制表符长度）==0）
n=（tab=resize（））。长度；
if（（p=tab[i=（n-1）&hash]）==null）
tab[i]=newNode（散列、键、值、null）；
否则{
节点e；K；
if（p.hash==hash&&
（（k=p.key）==key | |（key！=null&&key.equals（k）））
e=p；
else if（树节点的p实例）
e=（（TreeNode）p）.putTreeVal（this，tab，hash，key，value）；
否则{
对于（int-binCount=0；；++binCount）{
如果（（e=p.next）==null）{
p、 next=newNode（散列、键、值、null）；
如果（binCount>=TREEIFY_阈值-1）/-1为第一个
treeifyBin（选项卡，哈希）；
打破
}
如果（e.hash==hash&&
（（k=e.key）==key | |（key！=null&&key.equals（k）））
打破
p=e；
}
}
如果（e！=null）{//键的现有映射
V oldValue=e.value；
如果（！onlyFabSent | | oldValue==null）
e、 价值=价值；
节点接入后（e）；
返回旧值；
}
}
++modCount；
如果（++大小>阈值）
调整大小（）；
节点插入后（逐出）；
返回null；
}

在逻辑中，该方法返回给定键在映射中找到的上一个值…

这意味着你第一次这么做

put（1，“abc”）
它返回null，因为映射中没有任何内容。
如果你再这样做
put（1，“xyz”）
然后该方法返回“abc”，因为这是根据java文档在映射中找到的键=1的最后一个值：

put返回与键关联的上一个值，如果为空，则返回null
没有密钥的映射。（null返回也可以表示
如果实现失败，则映射先前与键关联为null
支持空值。）

在您的例子中，当您执行
map.put（1，“ABC”）
时，没有任何内容与
键1关联，因此它
返回空值
，但当您使用
put（1，“XYZ”）
时，则针对
键1已经存在一个
条目
，因此它返回“ABC”
映射中put方法的返回类型是值类型

put的方法声明：
V输入（K键，V值）

在哪里,

键：与指定值关联的键

值：与指定键关联的值

返回类型：与键关联的上一个值，如果键没有映射，则返回null。如果实现支持null值，则null返回还可以指示先前将null与key关联的映射

比如说-

System.out.println（map.put（1，“ABC”）；-->在这种情况下，没有与键1关联的值，因此它返回null

System.out.println（map.put（1，“XYZ”）；-->当针对已存储的键存储新值时，新值将替换以前的值，put方法将返回以前被覆盖的值。在这种情况下，它将返回ABC
它是值的类型（
中的
V
）。看见第一次获得
null
，因为映射中没有与键关联的值。您的代码不反映您的说法，也不生成您显示的输出。您可能打算打印
put
的结果，这也解释了输出。但在当前代码段中，您打印了
get
，这将产生不同的结果。它返回以前与键关联的值。好的，但为什么它一次返回null，另一次返回“ABC”？请详细说明一下，这个函数返回指定键的旧值。起初，它不存在，所以没有旧的价值。另一方面，当您在下一步中更新该值时，它将返回第一个值。例如，如果您再次更新它，它应该返回
“XYZ”
。他正在执行
System.out.println（map.get（1））
这不是预期的行为？？
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }