Java 为什么以下代码的输出是1而不是0？ @测试 公开无效测试（）{ Map a=新的HashMap（）； a、 放入（“x”，新整数（0））； 整数i=a.get（“x”）； a、 put（“x”，i++）； i=a.get（“x”）； a、 put（“x”，i++）； i=a.get（“x”）； a、 put（“x”，i++）； 系统错误println（i）； }

上述代码的输出为1，而不是0。我不明白为什么。有人能解释一下发生了什么事吗？

---

Java的某些字节码优化会导致这种状态？

因为

i++

在递增之前返回

i

。见我的评论：

    @Test
    public void test(){
        Map<String, Integer> a = new HashMap<>();
        a.put("x", new Integer(0));
        Integer i = a.get("x");
        a.put("x", i++);
        i = a.get("x");
        a.put("x", i++);
        i = a.get("x");
        a.put("x", i++);
        System.err.println(i);
    }

Map a=newhashmap（）；
a、 放置（“x”，新整数（0））；//x=0
整数i=a.get（“x”）；//i=0
a、 put（“x”，i++）；//x=0，i=1
i=a.get（“x”）；//i=0
a、 put（“x”，i++）；//x=0，i=1
i=a.get（“x”）；//i=0
a、 put（“x”，i++）；//x=0，i=1
系统错误println（i）；

以下是来自以下网站的相关部分：

递增/递减运算符可以应用于操作数之前（前缀）或之后（后缀）。代码

result++

和

++结果将以结果递增1结束

唯一的区别是前缀版本（
++result
）的计算结果为递增值，而后缀版本（
result++
）的计算结果为原始值。

如果您只是执行一个简单的递增/递减操作，那么选择哪个版本并不重要。但是，如果在较大表达式的一部分中使用此运算符，则选择的运算符可能会产生显著的差异

因为
i++
在递增之前返回
i
。见我的评论：

    @Test
    public void test(){
        Map<String, Integer> a = new HashMap<>();
        a.put("x", new Integer(0));
        Integer i = a.get("x");
        a.put("x", i++);
        i = a.get("x");
        a.put("x", i++);
        i = a.get("x");
        a.put("x", i++);
        System.err.println(i);
    }

Map a=newhashmap（）；
a、 放置（“x”，新整数（0））；//x=0
整数i=a.get（“x”）；//i=0
a、 put（“x”，i++）；//x=0，i=1
i=a.get（“x”）；//i=0
a、 put（“x”，i++）；//x=0，i=1
i=a.get（“x”）；//i=0
a、 put（“x”，i++）；//x=0，i=1
系统错误println（i）；

以下是来自以下网站的相关部分：

递增/递减运算符可以应用于操作数之前（前缀）或之后（后缀）。代码
result++
和
++结果将以结果递增1结束

唯一的区别是前缀版本（
++result
）的计算结果为递增值，而后缀版本（
result++
）的计算结果为原始值。

如果您只是执行一个简单的递增/递减操作，那么选择哪个版本并不重要。但是，如果在较大表达式的一部分中使用此运算符，则选择的运算符可能会产生显著的差异

是的，应该是一个。最后一个语句是
a.put（“x”，i++）
所以你把值
0
放入你的
映射中
，然后你增加
i
。如果您的上一个语句是
i=a.get（“x”）
您将得到
0
是的，它应该是一个。最后一个语句是
a.put（“x”，i++）
所以你把值
0
放入你的
映射中
，然后你增加
i
。如果您的上一个语句是
i=a.get（“x”）
如果使用后期增量，则会得到
0
，因此先读取
i
的值，然后再递增

Map<String, Integer> a = new HashMap<>();
a.put("x", new Integer(0)); // x=0
Integer i = a.get("x");     // i=0
a.put("x", i++);            // x=0, i=1
i = a.get("x");             // i=0
a.put("x", i++);            // x=0, i=1
i = a.get("x");             // i=0
a.put("x", i++);            // x=0, i=1
System.err.println(i);

@测试
公开无效测试（）{
Map a=新的HashMap（）；
a、 放入（“x”，新整数（0））；
整数i=a.get（“x”）；//i是0
a、 put（“x”，i++）；//x=0；然后i递增
i=a.get（“x”）；//i被重置为0
a、 put（“x”，i++）；//x=0；然后i递增
i=a.get（“x”）；//i被重置为0
a、 put（“x”，i++）；//x=0；然后i递增
System.err.println（i）；//i==1
}
您使用后增量，因此先读取
i
的值，然后再递增

Map<String, Integer> a = new HashMap<>();
a.put("x", new Integer(0)); // x=0
Integer i = a.get("x");     // i=0
a.put("x", i++);            // x=0, i=1
i = a.get("x");             // i=0
a.put("x", i++);            // x=0, i=1
i = a.get("x");             // i=0
a.put("x", i++);            // x=0, i=1
System.err.println(i);

@测试
公开无效测试（）{
Map a=新的HashMap（）；
a、 放入（“x”，新整数（0））；
整数i=a.get（“x”）；//i是0
a、 put（“x”，i++）；//x=0；然后i递增
i=a.get（“x”）；//i被重置为0
a、 put（“x”，i++）；//x=0；然后i递增
i=a.get（“x”）；//i被重置为0
a、 put（“x”，i++）；//x=0；然后i递增
System.err.println（i）；//i==1
}
内联解释：

 @Test
public void test(){
    Map<String, Integer> a = new HashMap<>();
    a.put("x", new Integer(0));
    Integer i = a.get("x"); // i is 0
    a.put("x", i++); // x = 0; then i increment
    i = a.get("x"); // i is reset to 0
    a.put("x", i++); // x = 0; then i increment
    i = a.get("x"); // i is reset to 0
    a.put("x", i++); // x = 0; then i increment
    System.err.println(i); // i == 1
}

@测试
公开无效测试（）{
Map a=新的HashMap（）；
a、 put（“x”，新整数（0））；//存储整数（0）
整数i=a.get（“x”）；//获取它
a、 put（“x”，i++）；//取消装箱，重新装箱，再次存储（仍然为0）；之后递增
i=a.get（“x”）；//再次相同
a、 放置（“x”，i++）；/。。。
i=a.get（“x”）；/。。。
a、 put（“x”，i++）；//取消装箱，重新装箱，再次存储（仍然为0）；之后递增
System.err.println（i）；//显示它；包含*递增*值
}

由于存储的值始终为0，因此在最后得到它并将其递增，最终得到1。

 @Test
public void test(){
    Map<String, Integer> a = new HashMap<>();
    a.put("x", new Integer(0));
    Integer i = a.get("x"); // i is 0
    a.put("x", i++); // x = 0; then i increment
    i = a.get("x"); // i is reset to 0
    a.put("x", i++); // x = 0; then i increment
    i = a.get("x"); // i is reset to 0
    a.put("x", i++); // x = 0; then i increment
    System.err.println(i); // i == 1
}

@测试
公开无效测试（）{
Map a=新的HashMap（）；
a、 put（“x”，新整数（0））；//存储整数（0）
整数i=a.get（“x”）；//获取它
a、 put（“x”，i++）；//取消装箱，重新装箱，再次存储（仍然为0）；之后递增
i=a.get（“x”）；//再次相同
a、 放置（“x”，i++）；/。。。
i=a.get（“x”）；/。。。
a、 put（“x”，i++）；//取消装箱，重新装箱，再次存储（仍然为0）；之后递增
System.err.println（i）；//显示它；包含*递增*值
}

由于存储的值始终为0，因此在最后得到它并将其递增，最终得到1。
让我们一步一步地完成此步骤：

@Test
public void test(){
    Map<String, Integer> a = new HashMap<>();
    a.put("x", new Integer(0)); // Store Integer(0)
    Integer i = a.get("x");     // Get it
    a.put("x", i++);            // Unbox it, rebox it, store it again (still 0); increment it afterward
    i = a.get("x");             // Same again
    a.put("x", i++);            // ...
    i = a.get("x");             // ...
    a.put("x", i++);            // Unbox it, rebox it, store it again (still 0); increment it afterward 
    System.err.println(i);      // Show it; contains the *incremented* value
}

我是0

    Integer i = a.get("x");

地图中的“x”不会改变，因为您将其设置为i（=0）并在设置后递增

    a.put("x", i++);

再次设置为0，因为这仍然是存储在“x”中的内容    a.put("x", i++);

    System.err.println(i);