一文打通：从字节码指令的角度解读前置后置自增自减（加加++减减--）

已于 2023-06-10 19:15:08 修改
阅读量1.5k 收藏 1
点赞数 1
分类专栏： # java基础知识 文章标签： java 数据结构 自增自减 字节码指令 jvm
于 2023-06-10 19:08:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62982856/article/details/131145447
版权
本文通过分析Java字节码指令，揭示了前置++和后置++在不同场景下的执行过程。在单独使用时，两者效率相同，但在需要返回值的情况下，后置++先复制再加1，而前置++先加1再复制。理解这些底层机制有助于深入理解Java程序的执行逻辑。
摘要由CSDN通过智能技术生成

文章目录

javac进行编辑源文件，生成 class 字节码二进制文件。解读 class 字节码文件当中的字节码指令，可以帮助我们更好理解程序执行过程的机理。

关于前置加加、后置加加，我们通常记得的是先加1再操作、先操作再加1。在本文中，我们将以 Java底层真正执行的字节码指令角度更好理解为什么是这样，在一些比较复杂的判断执行先后顺序的时候使用字节码指令进行判断会更加的简单！

1.前置了解的知识

1.1 栈这种数据结构

  • 栈是一个**先入后出(FILO-First In Last Out)**的有序列表。

  • 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的 一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

  • 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元 素最先删除，最先放入的元素最后删除。

栈数据结构.png

1.2 局部变量表和操作数栈

每个方法在被调用时都会分配一个独立的空间，该空间中又包括 局部变量表 和 操作数栈 两个部分。

  • 局部变量表 用来存储方法中定义的局部变量、方法参数等等，它是在编译时确定大小的，具体的大小可以在字节码中看到。
  • 操作数栈 用来存储方法执行中的操作数据，操作数栈是一个后进先出（LIFO）的数据结构，Java 虚拟机在执行指令时会将数据压入操作数栈中，然后再从栈中取出数据进行计算。

解读class字节码指令.png

1.3 三个字节码指令

public class ReadClass{
    public static void main(String[] args){
        int i = 10;
    }
}

编译生成：ReadClass.class

如何查看字节码？javap -c ReadClass.class，以上程序字节码如下：

public class ReadClass {
  public ReadClass();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    // 主要分析下面的指令
    Code:
       0: bipush        10
       2: istore_1
       3: return
}

重点研究 main 方法中的字节码含义：

  1. bipush 10 指令：将字面量 10 压入操作数栈。
  2. istore_1 指令：将操作数栈中顶部数据弹出，然后将该数据存放到局部变量表的第1个位置（第0个位置存储的方法的参数args）。
  3. return 指令：方法结束。
public class ReadClass{
    public static void main(String[] args){
        int i = 10;
        int j = i;
    }
}

编译生成：ReadClass.class，再 javap -c ReadClass.class，以上程序字节码如下：

public class ReadClass {
  public ReadClass();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       // 将 字面量 10 压入操作数栈
       0: bipush        10
       // 将操作数栈顶的数据 10 弹出，将该数据放入局部变量表第 1 个位置，即完成了将 10 赋值给 i 的操作
       2: istore_1
       // 将局部变量表中第 1 个位置存储的数据复制一份，放到操作数栈当中。
       3: iload_1
       // 将操作数栈顶的数据 10 弹出，将该数据放入局部变量表第 2 个位置，即完成了将 10 赋值给 j 的操作
       4: istore_2
       // 方法结束
       5: return
}
  • iload_1 指令：将局部变量表中第1个位置存储的数据复制一份，放到操作数栈当中。
  • istore_2 指令：将操作数栈顶部数据弹出，将其存放到局部变量表的第2个位置上。

2.单独使用后置++与前置++

由于 ++ 与 – 原理相同，这里就以 ++ 为例进行演示。

2.1 后置++字节码指令

public class ReadClass{
    public static void main(String[] args){
        int i = 10;
        i++;
    }
}

编译生成：ReadClass.class，再 javap -c ReadClass.class，以上程序字节码如下：

public class ReadClass {
  public ReadClass();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       // 将 字面量 10 压入操作数栈
       0: bipush        10
       // 将操作数栈顶的数据 10 弹出，将该数据放入局部变量表第 1 个位置，即完成了将 10 赋值给 i 的操作
       2: istore_1
       // 将局部变量表第 1 个位置的数据加 1，即从 10 变成了 11
       3: iinc          1, 1
       // 方法结束
       6: return
}
  • iinc 1, 1 指令：将局部变量表中第1个位置数据加1

2.2 前置++字节码指令

public class ReadClass{
    public static void main(String[] args){
        int i = 10;
        ++i;
    }
}

编译生成：ReadClass.class，再 javap -c ReadClass.class，以上程序字节码如下：

public class ReadClass {
  public ReadClass();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       // 将 字面量 10 压入操作数栈
       0: bipush        10
       // 将操作数栈顶的数据 10 弹出，将该数据放入局部变量表第 1 个位置，即完成了将 10 赋值给 i 的操作
       2: istore_1
       // 将局部变量表第 1 个位置的数据加 1，即从 10 变成了 11
       3: iinc          1, 1
       // 方法结束
       6: return
}
  • iinc 1, 1 指令：将局部变量表中第1个位置数据加1

2.3 总结

分析了单独使用前置++和后置++的指令，我们发现字节码指令是一样的，实际上都是将局部变量表对应位置的数据进行加1操作。

🚩 当单独使用 ++ 或 -- 时，不需要关心其返回值，因此前置和后置的效率是一样的。实际上，在编译时，编译器可能会将单独使用的 ++ 或 -- 运算符优化为一条简单的指令 iinc，因此在机器指令级别上，它们的执行效率是相同的。

3.需要返回值的情况下使用后置++与前置++

3.1 后置++字节码指令

public class ArithmeticOperator {
    public static void main(String[] args) {
        /*
        	后置 ++ 字节码指令：
        	
            public class ArithmeticOperator {
              public ArithmeticOperator();
                Code:
                   0: aload_0
                   1: invokespecial #1                  // Method java/lang/Object."<init>":()V
                   4: return

              public static void main(java.lang.String[]);
                Code:
                   0: bipush        10
                   2: istore_1
                   3: iload_1
                   4: iinc          1, 1
                   7: istore_2
                   8: return
            }
         */

        /*
            0: bipush 10：将数据 10 放到操作数栈中
            2: istore_1：将操作数栈顶数据 10 弹出赋值给变量i，即存到局部变量表第1个位置
         */
        int i = 10;

        /*
            3: iload_1 将局部变量表第1个位置的数据 10 复制一份放入到操作数栈
            4: iinc 1, 1 将局部变量表第1个位置的数据 10 自加1 变为 11
            7: istore_2 将操作数栈顶数据 10 弹出赋值给变量k，即存到局部变量表第2个位置
         */
        int k = i++;
    }
}

我们可以看到在 int k = i++; 这条语句中，实际执行了三个字节码指令：

  1. iload_1：将局部变量表第1个位置的数据 10 复制一份放入到操作数栈。
  2. iinc 1, 1：将局部变量表第1个位置的数据 10 自加1 变为 11。
  3. istore_2：将操作数栈顶数据 10 弹出赋值给变量k，即存到局部变量表第2个位置。

因此，我们在谈到 后置++ 时，通常说是 先操作再加1 ，那实际上：

  • 这个“先操作”从字节码指令的角度看就是先将局部变量表的对应数据复制一份压入操作数栈；
  • “再加1”就是再将局部变量对应数据加1，而操作数栈中保存的数据还是原本数据。
  • 紧接着的 对k的赋值 操作实际是 从操作数栈顶弹出原本数据存储到局部变量表即赋值给k。

3.2 前置++字节码指令

public class ArithmeticOperator {
    public static void main(String[] args) {
        /*
            public class ArithmeticOperator {
              public ArithmeticOperator();
                Code:
                   0: aload_0
                   1: invokespecial #1                  // Method java/lang/Object."<init>":()V
                   4: return
            
              public static void main(java.lang.String[]);
                Code:
                   0: bipush        10
                   2: istore_1
                   3: iinc          1, 1
                   6: iload_1
                   7: istore_2
                   8: return
            }
         */

        /*
            0: bipush 10：将数据 10 放到操作数栈中
            2: istore_1：将操作数栈顶数据 10 弹出赋值给变量i，即存到局部变量表第1个位置
         */
        int i = 10;

        /*
            3: iinc 1, 1 将局部变量表第1个位置的数据 10 自加1 变为 11
            6: iload_1 将局部变量表第1个位置的数据 11 复制一份放入到操作数栈
            7: istore_2 将操作数栈顶数据 11 弹出赋值给变量k，即存到局部变量表第2个位置
         */
        int k = ++i;
    }
}

3.3 总结

在需要返回值的情况下我们比较发现：

  • 后置++（先操作再加1）：先复制一份局部变量表对应数据压入到操作数栈，再将局部变量表对应数据加1。
  • 前置++（先加1再操作）：先将局部变量表对应数据加1，再复制一份局部变量表对应数据压入到操作数栈。

这里就可以看出压入到操作数栈的数据是不同的，那么最后弹出 操作数栈顶的该数据 作为 返回值 进行 赋值操作的结果也是不同的。

3.4 练习

🍀 练习一

int a = 5;
int b = a++; // 先复制一份数据压入操作数栈，再将局部变量表数据+1，最后从栈中弹出数据作为返回值赋值给 b
System.out.println("b = " + b); // 5
b = a++;
System.out.println("a = " + a); // 7
System.out.println("b = " + b); // 6

int c = 10;
int d = --c; // 先将数据-1，再复制一份压入操作数栈，再从栈中弹出该数据作为返回值赋值给 d
System.out.println("c = " + c); // 9
System.out.println("d = " + d); // 9

🍀 练习二

int i = 10;
/*
	等式右边从左向右执行：
	- 先 i++：复制一份数据 10 到操作数栈，将局部变量表数据+1变为11，弹出操作数栈中数据 10 作为返回值，即 i++ 的返回值是 10，i变成了 11
	- 再 ++i：将局部变量表数据 11 加1变为 12，复制一份数据 12 到操作数栈，弹出栈中数据 12 作为返回值，即 ++i 的返回值是 12，i变成了 12
	- 最后 10 + 12 得到 22 赋值给 k
*/
int k = i++ + ++i; 
System.out.println(k); // 22

int f = 10;
/*
	等式右边从左向右执行：
	- 先 f++：复制一份数据 10 到操作数栈，将局部变量表数据+1变为11，弹出操作数栈中数据 10 作为返回值，即 f++ 的返回值是 10，f变成了 11
	- 即 ( f++ + f ) 变为了 ( 10 + f )：此时 f 的值变成了 11 ，因此 将 (10 + 11) 的结果赋值给 m
	- 最后 10 + 12 得到 22 赋值给 k
*/
int m = f++ +f;
System.out.println(m); // 21
System.out.println(f); // 11

4.⭐ 经典面试题

4.1 后置++

/*
    0: bipush 10：将数据 10 放到操作数栈中
    2: istore_1：将操作数栈顶数据 10 弹出赋值给变量i，即存到局部变量表第1个位置
 */
int i = 10;
/*
    3: iload_1 将局部变量表第1个位置的数据 10 复制一份放入到操作数栈
    4: iinc 1, 1 将局部变量表第1个位置的数据 10 自加1 变为 11
    7: istore_1 将操作数栈顶数据 10 弹出放到局部变量表第1个位置即将 10 赋值给变量i
 */
i = i++;
System.out.println(i); // 10

4.2 前置++

/*
    0: bipush 10：将数据 10 放到操作数栈中
    2: istore_1：将操作数栈顶数据 10 弹出赋值给变量i，即存到局部变量表第1个位置
 */
int i = 10;

/*
    3: iinc 1, 1 将局部变量表第1个位置的数据 10 自加1 变为 11 
    6: iload_1 将局部变量表第1个位置的数据 11 复制一份放入到操作数栈
    7: istore_1 将操作数栈顶数据 11 弹出放到局部变量表第1个位置即将 11 赋值给变量i
 */
i = ++i;
System.out.println(i); // 11
是谢添啊
关注
专栏目录
Spring Boot入门(15)：【实战教程】Spring Boot + MyBatis-Plus 自动生成骨架代码，告别枯燥的重复劳动！
**My Coding Family**
05-08 3045
Spring Boot 整合 MyBatis-Plus AutoGenerator 自动生成项目骨架代码，一文教会你。
Spring Boot进阶(03)：【实战教程】MyBatis-Plus秒级实现字段自动填充，让你的代码更优雅！
**My Coding Family**
04-03 9996
如何使用MyBatis-Plus提供的@TableField注解实现字段自动填充？这你若不会，还不点进来瞅瞅！或许就捡到宝啦。
c++中的前置和后置加加没你想的这么简单
m0_64647636的博客
03-15 3084
1.前置++和后置++的区别1： 前置是先加后赋值，后置是先赋值再加。 2.前置++比后置++运行的速度快： 在汇编底层中后置++会比前置++多一行。 当然我这demo不是很准确毕竟也是有偶然的，但是确实是前置++快 3.作为学者的我们应该一探究竟。 其实前置++是不用产生中间变量的。而后置++产生了个中间变量接受了前面的值。 明确表示了左值不能赋值。 4.那这样子的话有啥用呢？ ...
前置加加和后置加加
weixin_46063356的博客
07-13 462
#include<stdio.h> int main() { int a = 0,b=0,c=0，d=0; c=a++; d=++b; printf("c=%da++=%d\n", c,a); } 后置加加： 先创建一个临时变量用于存放a并且赋值给c（即为0，未实现加1的操作）,然后再创建一个临时变量实现a+1且回显给a（即a已经变为了1 ） 前置加加：先创建一个临时变量实现加一的操作，再创建一个临时变量存储加一后的b,然后赋值给d(即d=1) ...
前置++与后置++、前置--与后置--
热门推荐
star_yang的博客
05-14 1万+
前置++与后置++、前置–与后置– ++与–的知识点相同，在此只记录前置++与后置++的知识点。 1 基本区别 前置++是先自加再使用，而后置++是先使用再自加！ 此处自加自减指的是变量的值，使用指的是使用该变量。 即：前加加就是先加，然后才用这个变量；后加加就是先用这个变量，然后在对这个变量做自增。 例如： int i=10; i++;//此时，i++整体为10，然后i增加1，变为...
编译器能否优化后置自增操作符
jbluesun的专栏
08-20 909
如果你要让某个变量的值加1，可以用 i++;  也可以用++i; 通常，编码规范都建议我们如果考虑性能，这种情况下最好用前置自增，因为后置自增会多一次无用的复制操作。 但这种做法往往跟我们的习惯不相符，我自己还是看“i++”顺眼一点儿。   也许，编译器没那么傻，它们
后置加加C++
这是一个c++热爱者的博客哟
07-30 2388
代码】后置加加C++
一个 JS 写的 Table 自增/减行例子，和一个模态对话框传值例子的源代码
04-21
博客《一个 JS 写的 Table 自增/减行例子，和一个模态对话框传值例子的源代码》一文的示例完整源代码。博客地址：http://blog.csdn.net/defonds/archive/2010/04/21/5512015.aspx。
一文速学-XGBoost模型算法原理以及实现+贷款违约预测模型Python项目实战
master_hunter的博客
04-03 9072
集成模型Boosting补完计划第三期了，之前我们已经详细描述了AdaBoost算法模型和GBDT原理以及实践。通过这两类算法就可以明白Boosting算法的核心思想以及基本的运行计算框架，余下几种Boosting算法都是在前者的算法之上改良得到，尤其是以GBDT算法为基础改进衍生出的三种Boosting算法：XGBoost、LightGBM、CatBoost。大家应该都对XGBoost算法模型熟悉但是对GBDT模型一无所知，看过之前GBDT的读者应该对GBDT模型有了一个很清楚的认知，对于理解XGBoos
ROS2从入门到精通5-1：详解代价地图与costmap插件编写(以距离场ESDF为例)
最新发布
FRIGIDWINTER的博客
07-15 5297
一文总结ROS2代价地图的核心概念与配置，并以欧氏符号距离场障碍层为案例，介绍代价地图插件的编写方法，图文并茂加深理解
前置++与后置++
05-16
本文主要写了前置++ -- 与后置++ --在程序中的应用，让C/C++学习者能够清楚了解前置++ -- 与后置++　--的用法
前置++，后置++
qq_29567701的博客
09-17 1555
前置++，后置++ 题目： int a = 4, b = 4, c = 4, d = 4; a += (a++); b += (++b); ++c += c; ++d += d++; 测试1： int a = 4, b = 4, c = 4, d = 4; a += (a++); b += (++b); ++c += ...
一篇吃透前置加加和后置加加(附练习题)
罅隙的博客
12-23 1982
一篇搞定前置加加与后置加加
printf函数输出多个printf 、前置加加或者后置加加
weixin_42422557的博客
08-21 4199
目录 （1）前置加加和后置加加的区别 （2）printf输出前置加加 （3）printf输出后置加加 （4）printf输出printf （1）前置加加和后置加加的区别 首先我们先来了解一下前置加加和后置加加的区别。 前置加加在编译器里的操作 //++a int a = 0; a = a + 1; return a; 前置加加是先加一，后赋值，返回的值是加一之后的值。 后置加...
前加加、后加加区别
songxueyan214的专栏
07-05 1万+
前加加，就是先加，然后才用这个变量；后加加，就是先用这个变量，然后再用这个变量做自增。简单的说，前加加就是先加后调用，后加加就是先用后加。   var a = b = c = d = e = f = 1;  alert(a++);//1  alert(++b)
C语言运算符优先级（最详细版而且有针对性优化）（个人整理了部分常用的，避免查的头晕，还附了一些相关解释等） 比如自增自减运算符的两种方式的区别
ZSWAries的博客
03-30 3177
概念： 一、 C语言运算符是说明特定操作的符号，它是构造C语言表达式的工具 。C语言的运算异常丰富，除了控制语句和输入输出以外的几乎所有的基本操作都为运算符处理。除了常见的三大类，算术运算符、关系运算符与逻辑运算符之外，还有一些用于完成特殊任务的运算符，比如位运算符。二、 相同优先级运算符，从左至右依次运算。 注意后缀运算优先级高于前缀。因此++i++应解释为++(i++)。 ...
前置加加与后置加加的区别
weixin_43831728的博客
02-04 6822
基本概念： 前置加加：前置++是先自加再使用，此处自加指的是变量的值，使用指的是使用该变量自增之后的值用以计算。即：前++就是先++，然后才用这个变量。 后置加加：后置++是先使用再自加，此处自加指的是变量的值，使用指的是使用该变量没有自增之前的值用来计算。即：后++就是先使用这个变量的值，然后再++。 代码如下所示： #include<stdio.h> int main() { ...
前置加加，后置加加有什么区别
2301_78131481的博客
08-16 890
前置加加 口诀：先加一，后使用。 先取a的值，再a自增1，后与其他运算符结合。 后置加加 口诀：先使用，后加一。 先取a的值，与其他运算符结合，后a自增1。
Cortex-M处理器架构详解：编程模型与安全特性
"一文解析Cortex-M处理器架构特性" Cortex-M处理器是ARM公司推出的微控制器系列，旨在提供高效能、低功耗的解决方案，广泛应用于单片机和深度嵌入式系统。其架构特性包括以下几个核心方面： 1. **编程模型**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是谢添啊

感谢你的支持，我会继续加油的

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值