1. 运算符的总体图谱先搞清楚我们到底在学什么如果你去翻 Java 的教材或者看网上的面试八股文会发现运算符这块内容永远排在“基础语法”的第三节、第四节但很多人的真实状态是学过、会认、敢写一追问底层原理就露馅。尤其是和equals的区别、和的短路差异、i和i的赋值时机这些高频面试题能难住一批工作两三年的开发。所以这篇东西我打算换个讲法不按书上的顺序平铺直叙而是先建立一个整体认知框架再逐个击破关键点最后给出能直接抄作业的实战排查经验。Java 的运算符按功能可以粗暴分成六大类算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、三元运算符。再加上两个容易被忽略的“特殊角色”——类型转换运算符()强制转换和instanceof类型检查运算符。这个分类方式不是我的发明但我的体会是只有先把这个图谱刻在脑子里后面看源码、调 bug 的时候才不会乱。从 JVM 的角度看运算符本质上是字节码指令的“语法糖”。比如int a b c里的在字节码层面会被编译成iadd指令a b会被编译成if_icmple等条件跳转指令。所以你在学运算符的时候学的不只是“怎么写”更是“Java 编译器会把这些写法翻译成什么”。这个视角一旦建立很多“为什么这么设计”的问题就迎刃而解了。还有个常被忽略的点运算符是有“优先级”和“结合性”的但大多数人在写代码时根本没意识到这一点。比如int result a b * c因为*的优先级高于所以实际执行的是a (b * c)而不是(a b) * c。如果这段代码是别人写的你没注意优先级读代码的时候就会产生误解。这就是为什么我强烈建议所有表达式里只要超过一个运算符一律加括号。不是为了显得专业是为了让三个月后的自己和同事不用拿笔推算运算顺序。1.1 用买菜理解六类运算符我给学生讲运算符的时候最喜欢用的类比是“去菜市场买菜”。假设你身上有 100 块钱土豆 3 块一斤买了 5 斤西红柿 2.5 块一斤买了 4 斤最后还剩多少钱算术运算符3 * 5 152.5 * 4 10这些都是“数值之间的计算”。赋值运算符money money - 15 - 10把计算结果存回变量。比较运算符money 0判断钱够不够。逻辑运算符money 0 hasBasket true判断“钱够”且“有袋子装”。位运算符你买东西按“整元”结算3.7 元直接只收 3 元这就是向下取整本质上类似对二进制位的处理。三元运算符return money 0 ? 够 : 不够就是一个简易 if-else 的语法糖。类比永远不是严密的但好处是能让你在 30 秒内建立直觉。真正写代码的时候你需要的是精确的规则而不是直觉。所以下面的内容我会把每个运算符的精确语义、类型转换规则、边界情况全部拉出来说一遍。2. 算术运算符与赋值运算符你以为是常识其实到处是坑2.1 算术运算符加减乘除模以及那个魔鬼般的“除法”Java 的算术运算符有六个、-、*、/、%取余也叫取模、自增、--自减。严格算起来是七个但、--属于一元运算符后面单独讲。最容易被忽视的坑是整数除法。7 / 2在数学里是 3.5但在 Java 里如果两个操作数都是整数结果是3直接丢掉小数部分而且不是四舍五入是向零取整。-7 / 2的结果是-3不是-4。很多人会误以为 Java 的整数除法是向下取整floor division其实 Java 的整数除法是 truncation也就是直接丢弃小数部分向零靠拢。这一点和 Python 的//完全不同Python 是真正的向下取整-7 // 2在 Python 里结果是-4。取余运算符%也有类似的陷阱。-7 % 2在 Java 里结果是-1结果是“被除数的符号”。这个符号规则在 LeetCode 刷题、处理数组下标回绕的时候特别容易踩坑。我的经验是如果你需要“永远非负”的取模结果比如循环队列的下标回绕可以这样写int mod ((a % b) b) % b;为什么先加一个b再取模因为 Java 的%结果可能为负加一个b保证结果落在[0, b-1]区间。比如-1 % 5 -1(-1 5) % 5 4刚好是我们想要的下标。再就是除以零的问题。整数除以零会抛ArithmeticException: / by zero这是运行时异常编译器不会帮你检查。浮点数除以零不会抛异常结果是Infinity或NaN。很多人觉得 Java 浮点运算“宽松”其实这恰恰是 IEEE 754 规范的要求。0.0 / 0.0的结果是NaN而且NaN ! NaN这就是为什么你用if (x Double.NaN)永远不可能为true必须用Double.isNaN(x)来判断。最后是精度问题。我在实际项目中见过太多因为double做金额计算导致线上事故的情况。0.1 0.2在 Java 里输出是0.30000000000000004因为二进制无法精确表示 0.1。金额计算必须用BigDecimal这是铁律。2.2 自增自减的魔鬼细节i和i到底差在哪面试必考题。i是“先取值后自增”i是“先自增后取值”。单纯的i和i单独成句时效果完全一样区别只出现在表达式里。看这道题int i 3; int result i; // result 3, i 4再看这个int i 3; int result i; // result 4, i 4真正的魔鬼题是这样的int i 3; i i; // i 最终等于多少答案是3。很多人不理解。原因要回到 JVM 的运算机制i的执行过程是先把 i 的当前值压入操作数栈然后对局部变量表的 i 做加一操作。等号右边的表达式结束以后栈里的值是3然后把栈里的 3 赋值给局部变量 i所以 i 被覆盖回 3。这个过程如果你没看过 JVM 的局部变量表和操作数栈永远只能死记硬背。我在公司带新人的时候遇到这个问题就直接打开 IDEA 的字节码插件把i对应的iload、iinc、istore字节码指令指给他们看瞬间就明白了。2.3 赋值运算符不只是“等于”那么简单赋值运算符除了还有复合赋值运算符、-、*、/、%、、|、^、、、。注意复合赋值运算符自带强制类型转换。看这段代码short s 1; s s 1; // 编译报错不兼容的类型 s 1; // 编译通过实际执行了 s (short)(s 1)为什么s s 1编译不过因为s 1的结果是int不能直接赋值给short。而s 1是等价于s (short)(s 1)编译器偷偷帮我们做了类型转换。这个机制在《Java 语言规范》里有明确说明但大多数人不知道。所以你要是看到别人用s 1不用觉得奇怪这不是偷懒是语法规定的。还有一个经常被面试官拿来考的点a b c 100的赋值顺序。赋值运算符是右结合的所以它等同于a (b (c 100))先把 100 赋给 c再把 c 的值赋给 b最后赋给 a。C 语言也是这个规则但 Java 里有个类型检查的问题如果变量类型不同可能编译失败。3. 比较运算符与逻辑运算符的坑的短路还有那个魔鬼的boolean3.1和equals对比的是值还是地址先想清楚比较运算符包括、、、、、!。前四个只能用于基本数据类型数值类型和!可以用在所有类型上但这正是坑最多的地方。对于基本数据类型比较的是值本身。对于引用类型比较的是内存地址引用是否指向同一个对象。所以你写new String(abc) new String(abc)结果是false因为两个字符串是堆里不同对象。但字符串常量池又把这个坑搅浑了String a abc; String b abc; System.out.println(a b); // 可能为 true因为abc是字符串字面量JVM 会把它放进常量池a和b都指向常量池里的同一个实例所以是true。如果你用new String(abc)创建就是堆里的新对象是false。我的建议简单粗暴判断字符串内容永远用equals不要用。对于 Integer 类型的比较也有大坑。JVM 对-128到127之间的 Integer 做了缓存所以Integer a 100; Integer b 100; a b是true但Integer a 200; Integer b 200; a b是false。这个缓存的默认上限127可以通过 JVM 参数-XX:AutoBoxCacheMax调整但没人会调。凡是包装类型比较一律用equals。3.2 逻辑运算符和不只是少写一个字符逻辑运算符有短路与、||短路或、!取反、不短路与、|不短路或、^异或。核心区别在于“短路”行为。左边为false时右边根本不会执行左边不管是什么右边都会执行。看这个经典场景if (user ! null user.getName().equals(admin)) { // 安全user 为 null 时不会进入 } if (user ! null user.getName().equals(admin)) { // 危险user 为 null 时 NPE }第二行会抛出NullPointerException因为它执行了user.getName()。这就是短路的实际价值它能作为“安全访问”的屏障。不过 Java 8 以后有了Objects.nonNull和 Optional这种写法逐渐减少了但理解短路机制本身还是很重要因为面试官一定会问。^异或运算符稍微冷门一点。true ^ true falsetrue ^ false true。在实际开发里我见过用它做“切换开关”的比如用户权限的两种状态切换flag flag ^ true每次执行都翻转一次。但其实三元运算符更清晰。还有一个面试高频题用逻辑运算符判断闰年。写法是(year % 4 0 year % 100 ! 0) || year % 400 0。这里体现的就是短路与、短路或的组合使用。注意的优先级高于||所以上面的表达式实际是((year % 4 0 year % 100 ! 0) || (year % 400 0))括号可以不写但加了更清晰。3.3 逻辑运算符用在“非 boolean”上是什么鬼、|、^在“位运算”的场景下也可以操作整数类型。int a 5 3这里的是位运算符不是逻辑运算符。很多新手在读到这段代码时会困惑。判断标准很简单操作数是 boolean 就是逻辑运算操作数是整数就是位运算。4. 位运算符冷门但强大读源码和性能优化必会4.1 六个位运算符逐个讲左移、右移、无符号右移Java 的位运算符包括按位与、|按位或、^按位异或、~按位取反、左移、带符号右移、无符号右移。以int为例它是 32 位有符号整数用补码表示。5的二进制是00000000 00000000 00000000 00000101。5 2左移两位结果是20。左边移出去的位丢弃右边补 0。每左移一位相当于乘 2。5 2带符号右移两位结果是1。右边移出去的位丢弃左边补的是符号位。5 2 1-5 2 -2。右移一位相当于整除 2。5 2无符号右移左边始终补 0。-5 2结果是很大的正数因为符号位被当成数值位一起移了。注意移位运算符只对 int 和 long 有效。如果你对 byte、short、char 做移位Java 会先把它提升为 int然后做移位。byte b 1; b 2的结果是 int不是 byte。还有一个冷知识int移位时移位位数会先对 32 取模。1 32等价于1 0结果是 1。因为 JVM 在底层使用了shift 0x1f针对 int来限制位移位数。这个行为在 Java 和 C 里是一致的但如果你预期的是“溢出变成 0”那就大错特错了。4.2 位运算的真实应用场景从 HashMap 到权限系统很多人觉得位运算在业务开发里用不上但 JDK 源码里全是位运算。以HashMap为例它的容量始终是 2 的幂次方为了实现快速取模它用的是(n - 1) hash而不是hash % n。为什么因为位运算比取模快得多。这就是为什么 HashMap 扩容后rehash的逻辑如此精妙。另一个常见场景是权限系统的位掩码。比如你有四个权限读1、写2、执行4、删除8用一个 int 就能把四个权限打包int READ 1 0; // 1 int WRITE 1 1; // 2 int EXEC 1 2; // 4 int DELETE 1 3; // 8 int userPermission READ | WRITE; // 3 boolean canWrite (userPermission WRITE) ! 0; // true这种写法在处理大量权限组合时非常优雅而且性能极高。我在做后台管理系统时经常用这种方式管理菜单权限一个int字段就把所有权限存进数据库了。4.3 异或运算的三条铁律异或运算有几个特性在算法题里极其常用a ^ 0 a任何数与 0 异或等于自身a ^ a 0任何数与自身异或等于 0异或满足交换律和结合律利用这三条可以在不使用临时变量的情况下交换两个整数int a 3, b 5; a a ^ b; // a 3 ^ 5 b a ^ b; // b 3 ^ 5 ^ 5 3 a a ^ b; // a 3 ^ 5 ^ 3 5还能在数组里找出唯一出现奇数次的数——把所有数全部异或一遍剩下的就是那个唯一没成对的数。这类题目在 LeetCode 上经常出现掌握了异或特性两三行代码就是最优解。5. 三元运算符与类型转换运算符写起来爽坑起来也爽5.1 三元运算符的类型自动提升问题三元运算符也叫条件运算符语法是条件表达式 ? 值1 : 值2。它本质是一个“表达式”有返回值可以被赋值。比如int max a b ? a : b。但三元运算符有一个大坑类型自动提升。看这段代码char gender 男; int age 30; Object result age 18 ? gender : age; // result 的值是 30004不是字符 男 或者数字 30因为三元运算符要求两个分支如果是基本类型会自动进行“二进制数值提升”。char和int会被提升为 int所以男的整数值 30004 被赋给了 result。这种隐式类型转换在代码评审时很难被发现尤其是分支类型是char、byte、short和int组合时。更隐蔽的是三元运算符和null结合时的空指针问题MapString, Integer map new HashMap(); Integer a null; Integer b 1; int result map ! null ? a : b; // NPE因为三元的整体类型被自动拆箱为 int这里的规则是如果两个操作数之一是int另一个是Integer整个表达式会被提升为int类型而Integer null拆箱时就抛NullPointerException。这个 bug 我在生产环境里遇到过排查了一个下午才知道是三元运算符合法拆箱惹的祸。5.2 类型转换运算符强转不是万能的类型转换运算符就是把一个类型强制转成另一个类型写法是在值前面加括号(int) 3.7。强制类型转换分为两种基本类型强转double转int会截断小数部分long转int会截断高位可能丢失数据。引用类型强转把父类对象转成子类类型如果实际对象不是该子类型运行时会抛ClassCastException。关于基本类型强转最经典的问题是int转byte。int i 200; byte b (byte) i;结果是-56。因为 int 的 200 是00000000 00000000 00000000 11001000转成 byte 只保留低 8 位11001000即十进制的 200但因为最高位是 1按补码解读就是 -56。这个知识点在面试里很常见但实际工作中较少直接用更多的是在读取二进制协议数据时才会遇到。引用类型强转的一个必要条件是“目标类型和实际类型之间有父子关系”否则编译器直接报错。如果你不确定实际类型最好先用instanceof检查if (obj instanceof String str) { // 现代 Java 的 pattern matching可以直接声明变量 }Java 16 以后支持instanceof的 pattern matching上面的写法比先判断再强转干净得多。5.3instanceof的边界判断instanceof运算符用于判断一个对象是不是某个类的实例包括子类、接口实现类。null instanceof AnyClass的结果是false这是规则不需要额外考虑空指针。有一个容易混淆的概念instanceof检查的是“实际对象类型”不是“引用的声明类型”。比如Object obj str; System.out.println(obj instanceof String); // true System.out.println(obj instanceof Object); // true因为obj实际指向的是 String 对象而 String 同时是 Object 的子类。6. 运算符优先级别再靠背了三个原则保平安6.1 优先级高低到底怎么排很多教材都会列一张很大的优先级表从()到赋值运算符十几行。我的建议是不用背记住几个关键节点就行。Java 运算符优先级从高到低的核心顺序后缀运算符expr、expr--、()、[]、.最高一元运算符expr、--expr、expr、-expr、~、!乘除*、/、%加减、-移位、、关系运算、、、、instanceof相等比较、!按位与按位异或^按位或|逻辑与逻辑或||三元运算符? :赋值运算符、等最低注意几个容易混淆的点的优先级高于^^高于|这三个都高于和||。所以a b c实际是a (b c)。还有移位运算符的优先级在加减之后所以1 2 3是(1 2) 3结果是 24不是1 (2 3)的 17。6.2 我的实战原则优先级规则即使记住了读代码时仍然容易出错。我的原则只有三条凡是有两个以上运算符的表达式一律用括号明确顺序。三元运算符嵌套超过一层改成 if-else 或 switch。位运算混入算术运算或比较运算时必须加括号。比如(num 1) 0判断 num 是不是偶数如果不加括号num 1 0会因为的优先级高于而被解析成num (1 0)编译直接报错。这个错误在代码评审里我见过好几次都是因为迷信自己的记忆力。7. 实操从零写一个带运算符优先级的简易计算器7.1 功能定义与思路拆解学运算符最好的方式不是背书而是写一个需要综合运用各类运算符的小程序。我建议初学者实现一个简易的整数四则运算计算器支持、-、*、/、%、括号并且正确处理运算符优先级。这个项目看似简单但要实现得干净实际上要用到栈和运算符优先级表。整体思路是将中缀表达式人类写的3 4 * 2转换为后缀表达式也叫逆波兰表达式3 4 2 * 使用调度场算法。对后缀表达式求值使用操作数栈。关键点需要一个比较运算符优先级的 map。这个项目能很好地检验你对运算符、栈、字符串处理的理解。而且它的扩展空间很大——从四则运算扩展到支持位运算、幂运算不过那已经是进阶玩法了。7.2 核心代码与实操注释先定义一个运算符优先级表和判断方法import java.util.HashMap; import java.util.Map; public class OperatorPrecedence { private static final MapCharacter, Integer PRECEDENCE new HashMap(); static { PRECEDENCE.put(, 1); PRECEDENCE.put(-, 1); PRECEDENCE.put(*, 2); PRECEDENCE.put(/, 2); PRECEDENCE.put(%, 2); } public static boolean isOperator(char c) { return PRECEDENCE.containsKey(c); } public static int comparePrecedence(char op1, char op2) { return PRECEDENCE.get(op1) - PRECEDENCE.get(op2); } }然后是中缀转后缀的核心方法import java.util.ArrayDeque; import java.util.Deque; public class InfixToPostfix { public static String convert(String expression) { StringBuilder output new StringBuilder(); DequeCharacter operators new ArrayDeque(); for (char ch : expression.toCharArray()) { if (Character.isDigit(ch)) { output.append(ch); } else if (ch () { operators.push(ch); } else if (ch )) { while (!operators.isEmpty() operators.peek() ! () { output.append( ).append(operators.pop()); } operators.pop(); // 弹出 ( } else if (OperatorPrecedence.isOperator(ch)) { while (!operators.isEmpty() operators.peek() ! ( OperatorPrecedence.comparePrecedence(operators.peek(), ch) 0) { output.append( ).append(operators.pop()); } output.append( ); operators.push(ch); } } while (!operators.isEmpty()) { output.append( ).append(operators.pop()); } return output.toString().trim(); } }最后是后缀表达式求值import java.util.ArrayDeque; import java.util.Deque; public class PostfixEvaluator { public static int evaluate(String postfix) { DequeInteger stack new ArrayDeque(); String[] tokens postfix.split( ); for (String token : tokens) { if (token.isEmpty()) { continue; } if (Character.isDigit(token.charAt(0))) { stack.push(Integer.parseInt(token)); } else { int operator1 stack.pop(); int operator2 stack.pop(); switch (token.charAt(0)) { case - stack.push(operator2 operator1); case - - stack.push(operator2 - operator1); case * - stack.push(operator2 * operator1); case / - stack.push(operator2 / operator1); case % - stack.push(operator2 % operator1); default - throw new IllegalArgumentException(非法运算符: token); } } } return stack.pop(); } }这段代码里switch -的箭头语法是 Java 14 以后的新特性更简洁。你用传统冒号写法也可以。需要注意的坑operator2和operator1的顺序。后缀表达式的计算里先出栈的是右操作数。switch里用operator2 operator1来保证5 3 -计算的是5 - 3而不是3 - 5。表达式里没有空格时Character.isDigit(ch)的处理逻辑会失效。我这里为了示例简单假设输入数字都是个位数如果要支持多位数需要加缓冲去拼接连续数字。我建议完整版直接枚举String的每个字符遇到数字就扫描到非数字为止。7.3 实测验证与边界情况测试3 4 * 2转换后后缀表达式3 4 2 * 求值结果11符合预期。测试(3 4) * 2转换后3 4 2 *求值结果14符合预期。测试7 - 2 * 3转换后7 2 3 * -求值结果1符合7 - 6。边界情况空表达式split( )会得到[]循环里直接continue跳过。除以零PostfixEvaluator里7 / 0会抛ArithmeticException这是正常的建议在 UI 层统一捕获并提示。非法字符比如输入字母aCharacter.isDigit(token.charAt(0))为 false但也不是运算符会走到default分支抛异常。这里有个小 bug 风险如果 token 是负数比如后缀表达式里出现-3我的代码会把它当成运算符然后在stack.pop()时因为栈为空抛异常。所以完整的计算器还需要单独处理负数。我的建议是通过正则把字符串里的负号识别成一元运算符来处理但这就复杂了需要单独一篇来写。8. 高频面试题与避坑技巧速查表8.1 面试八股文中的运算符考点我整理了近两年 Java 面试里出现频率极高的运算符相关题目每道题背后都藏着至少一个容易忽略的细节问题答案要点i和i的区别先取值后自增 vs 先自增后取值字节码层面是局部变量表和操作数栈的配合和的区别短路 vs 不短路 两侧都会执行和equals的区别基本类型比较值、引用类型比较地址equals可以被重写String 默认比较内容int和Integer比较用的坑缓存范围-128~127超出范围用equals整数除法7 / 2等于几3直接丢弃小数向零取整-7 % 2等于几-1结果符号跟随被除数三元运算符的自动拆箱 NPE一个分支是int、另一个是Integer且为 null 时会 NPE复合赋值运算符的强转s 1等价于s (short)(s 1)位运算和 的优先级HashMap 为什么用(n - 1) hash当 n 是 2 的幂时与运算等价于取模但更快8.2 实战避坑清单以下是我这几年写代码、做代码评审时真正遇到过的坑每一个都让某个同事debug到怀疑人生检查浮点位运算不要直接用0.1 0.2 0.3的结果是 false。用Math.abs(a - b) 1e-9或者用 BigDecimal。switch和三元运算符结合时注意类型提升int a flag ? 1 : 2.0编译报错因为 1 会被提升为 double。不要依赖复合赋值运算符的强转特性long a Integer.MAX_VALUE; a 1;没问题但int b Integer.MAX_VALUE; b 1;会溢出为负数这种 bug 不报错最难排查。取余运算结果可能为负在做循环队列、哈希表下标计算时务必用((index % size) size) % size。位运算和逻辑运算混写必须加括号(num 1) 0不要写成num 1 0。BigDecimal构造器用字符串不要用doublenew BigDecimal(0.1)会有精度问题new BigDecimal(0.1)才是正确的。不要在字符串拼接上使用到一万次以上s a每次都会创建新 String 对象性能极差。用StringBuilder或StringBuffer。9. 写在最后运算符不止是语法更是 JVM 的底层逻辑这篇文章从运算符的分类、核心规则、优先级一路写到了简易计算器的实现和面试高频题。我尽量把每个知识点背后“为什么”的部分都挖出来了因为只有理解了原理才能真正记住规则。比如i i为什么等于 3如果你只背结论下次遇到j i i这种题照样懵但如果你理解了局部变量表和操作数栈这类题就是送分题。我个人在实际备课和带新人的过程中最深刻的体会是运算符这块内容看上去很基础但它其实是连接“Java 语法”和“JVM 字节码”的一座桥。搞清楚i的字节码指令你对 JVM 的理解就不再局限于书上的名词搞清楚HashMap为什么用位运算做取模你才算真正读懂了 JDK 源码。所以别嫌这些知识点简单越基础的东西越值得往深里挖。最后再分享一个小技巧我建议你用 IDEA 的Show Bytecode插件或者配合javap -c命令去反编译自己写的运算符表达式代码。当你亲眼看到i变成iload、iinc、istore三条指令时你对运算符的理解会提升一个维度。这比把教材看十遍都有用。 Java运算符底层原理与实战避坑：从JVM字节码到高频面试题
1. 运算符的总体图谱先搞清楚我们到底在学什么如果你去翻 Java 的教材或者看网上的面试八股文会发现运算符这块内容永远排在“基础语法”的第三节、第四节但很多人的真实状态是学过、会认、敢写一追问底层原理就露馅。尤其是和equals的区别、和的短路差异、i和i的赋值时机这些高频面试题能难住一批工作两三年的开发。所以这篇东西我打算换个讲法不按书上的顺序平铺直叙而是先建立一个整体认知框架再逐个击破关键点最后给出能直接抄作业的实战排查经验。Java 的运算符按功能可以粗暴分成六大类算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、三元运算符。再加上两个容易被忽略的“特殊角色”——类型转换运算符()强制转换和instanceof类型检查运算符。这个分类方式不是我的发明但我的体会是只有先把这个图谱刻在脑子里后面看源码、调 bug 的时候才不会乱。从 JVM 的角度看运算符本质上是字节码指令的“语法糖”。比如int a b c里的在字节码层面会被编译成iadd指令a b会被编译成if_icmple等条件跳转指令。所以你在学运算符的时候学的不只是“怎么写”更是“Java 编译器会把这些写法翻译成什么”。这个视角一旦建立很多“为什么这么设计”的问题就迎刃而解了。还有个常被忽略的点运算符是有“优先级”和“结合性”的但大多数人在写代码时根本没意识到这一点。比如int result a b * c因为*的优先级高于所以实际执行的是a (b * c)而不是(a b) * c。如果这段代码是别人写的你没注意优先级读代码的时候就会产生误解。这就是为什么我强烈建议所有表达式里只要超过一个运算符一律加括号。不是为了显得专业是为了让三个月后的自己和同事不用拿笔推算运算顺序。1.1 用买菜理解六类运算符我给学生讲运算符的时候最喜欢用的类比是“去菜市场买菜”。假设你身上有 100 块钱土豆 3 块一斤买了 5 斤西红柿 2.5 块一斤买了 4 斤最后还剩多少钱算术运算符3 * 5 152.5 * 4 10这些都是“数值之间的计算”。赋值运算符money money - 15 - 10把计算结果存回变量。比较运算符money 0判断钱够不够。逻辑运算符money 0 hasBasket true判断“钱够”且“有袋子装”。位运算符你买东西按“整元”结算3.7 元直接只收 3 元这就是向下取整本质上类似对二进制位的处理。三元运算符return money 0 ? 够 : 不够就是一个简易 if-else 的语法糖。类比永远不是严密的但好处是能让你在 30 秒内建立直觉。真正写代码的时候你需要的是精确的规则而不是直觉。所以下面的内容我会把每个运算符的精确语义、类型转换规则、边界情况全部拉出来说一遍。2. 算术运算符与赋值运算符你以为是常识其实到处是坑2.1 算术运算符加减乘除模以及那个魔鬼般的“除法”Java 的算术运算符有六个、-、*、/、%取余也叫取模、自增、--自减。严格算起来是七个但、--属于一元运算符后面单独讲。最容易被忽视的坑是整数除法。7 / 2在数学里是 3.5但在 Java 里如果两个操作数都是整数结果是3直接丢掉小数部分而且不是四舍五入是向零取整。-7 / 2的结果是-3不是-4。很多人会误以为 Java 的整数除法是向下取整floor division其实 Java 的整数除法是 truncation也就是直接丢弃小数部分向零靠拢。这一点和 Python 的//完全不同Python 是真正的向下取整-7 // 2在 Python 里结果是-4。取余运算符%也有类似的陷阱。-7 % 2在 Java 里结果是-1结果是“被除数的符号”。这个符号规则在 LeetCode 刷题、处理数组下标回绕的时候特别容易踩坑。我的经验是如果你需要“永远非负”的取模结果比如循环队列的下标回绕可以这样写int mod ((a % b) b) % b;为什么先加一个b再取模因为 Java 的%结果可能为负加一个b保证结果落在[0, b-1]区间。比如-1 % 5 -1(-1 5) % 5 4刚好是我们想要的下标。再就是除以零的问题。整数除以零会抛ArithmeticException: / by zero这是运行时异常编译器不会帮你检查。浮点数除以零不会抛异常结果是Infinity或NaN。很多人觉得 Java 浮点运算“宽松”其实这恰恰是 IEEE 754 规范的要求。0.0 / 0.0的结果是NaN而且NaN ! NaN这就是为什么你用if (x Double.NaN)永远不可能为true必须用Double.isNaN(x)来判断。最后是精度问题。我在实际项目中见过太多因为double做金额计算导致线上事故的情况。0.1 0.2在 Java 里输出是0.30000000000000004因为二进制无法精确表示 0.1。金额计算必须用BigDecimal这是铁律。2.2 自增自减的魔鬼细节i和i到底差在哪面试必考题。i是“先取值后自增”i是“先自增后取值”。单纯的i和i单独成句时效果完全一样区别只出现在表达式里。看这道题int i 3; int result i; // result 3, i 4再看这个int i 3; int result i; // result 4, i 4真正的魔鬼题是这样的int i 3; i i; // i 最终等于多少答案是3。很多人不理解。原因要回到 JVM 的运算机制i的执行过程是先把 i 的当前值压入操作数栈然后对局部变量表的 i 做加一操作。等号右边的表达式结束以后栈里的值是3然后把栈里的 3 赋值给局部变量 i所以 i 被覆盖回 3。这个过程如果你没看过 JVM 的局部变量表和操作数栈永远只能死记硬背。我在公司带新人的时候遇到这个问题就直接打开 IDEA 的字节码插件把i对应的iload、iinc、istore字节码指令指给他们看瞬间就明白了。2.3 赋值运算符不只是“等于”那么简单赋值运算符除了还有复合赋值运算符、-、*、/、%、、|、^、、、。注意复合赋值运算符自带强制类型转换。看这段代码short s 1; s s 1; // 编译报错不兼容的类型 s 1; // 编译通过实际执行了 s (short)(s 1)为什么s s 1编译不过因为s 1的结果是int不能直接赋值给short。而s 1是等价于s (short)(s 1)编译器偷偷帮我们做了类型转换。这个机制在《Java 语言规范》里有明确说明但大多数人不知道。所以你要是看到别人用s 1不用觉得奇怪这不是偷懒是语法规定的。还有一个经常被面试官拿来考的点a b c 100的赋值顺序。赋值运算符是右结合的所以它等同于a (b (c 100))先把 100 赋给 c再把 c 的值赋给 b最后赋给 a。C 语言也是这个规则但 Java 里有个类型检查的问题如果变量类型不同可能编译失败。3. 比较运算符与逻辑运算符的坑的短路还有那个魔鬼的boolean3.1和equals对比的是值还是地址先想清楚比较运算符包括、、、、、!。前四个只能用于基本数据类型数值类型和!可以用在所有类型上但这正是坑最多的地方。对于基本数据类型比较的是值本身。对于引用类型比较的是内存地址引用是否指向同一个对象。所以你写new String(abc) new String(abc)结果是false因为两个字符串是堆里不同对象。但字符串常量池又把这个坑搅浑了String a abc; String b abc; System.out.println(a b); // 可能为 true因为abc是字符串字面量JVM 会把它放进常量池a和b都指向常量池里的同一个实例所以是true。如果你用new String(abc)创建就是堆里的新对象是false。我的建议简单粗暴判断字符串内容永远用equals不要用。对于 Integer 类型的比较也有大坑。JVM 对-128到127之间的 Integer 做了缓存所以Integer a 100; Integer b 100; a b是true但Integer a 200; Integer b 200; a b是false。这个缓存的默认上限127可以通过 JVM 参数-XX:AutoBoxCacheMax调整但没人会调。凡是包装类型比较一律用equals。3.2 逻辑运算符和不只是少写一个字符逻辑运算符有短路与、||短路或、!取反、不短路与、|不短路或、^异或。核心区别在于“短路”行为。左边为false时右边根本不会执行左边不管是什么右边都会执行。看这个经典场景if (user ! null user.getName().equals(admin)) { // 安全user 为 null 时不会进入 } if (user ! null user.getName().equals(admin)) { // 危险user 为 null 时 NPE }第二行会抛出NullPointerException因为它执行了user.getName()。这就是短路的实际价值它能作为“安全访问”的屏障。不过 Java 8 以后有了Objects.nonNull和 Optional这种写法逐渐减少了但理解短路机制本身还是很重要因为面试官一定会问。^异或运算符稍微冷门一点。true ^ true falsetrue ^ false true。在实际开发里我见过用它做“切换开关”的比如用户权限的两种状态切换flag flag ^ true每次执行都翻转一次。但其实三元运算符更清晰。还有一个面试高频题用逻辑运算符判断闰年。写法是(year % 4 0 year % 100 ! 0) || year % 400 0。这里体现的就是短路与、短路或的组合使用。注意的优先级高于||所以上面的表达式实际是((year % 4 0 year % 100 ! 0) || (year % 400 0))括号可以不写但加了更清晰。3.3 逻辑运算符用在“非 boolean”上是什么鬼、|、^在“位运算”的场景下也可以操作整数类型。int a 5 3这里的是位运算符不是逻辑运算符。很多新手在读到这段代码时会困惑。判断标准很简单操作数是 boolean 就是逻辑运算操作数是整数就是位运算。4. 位运算符冷门但强大读源码和性能优化必会4.1 六个位运算符逐个讲左移、右移、无符号右移Java 的位运算符包括按位与、|按位或、^按位异或、~按位取反、左移、带符号右移、无符号右移。以int为例它是 32 位有符号整数用补码表示。5的二进制是00000000 00000000 00000000 00000101。5 2左移两位结果是20。左边移出去的位丢弃右边补 0。每左移一位相当于乘 2。5 2带符号右移两位结果是1。右边移出去的位丢弃左边补的是符号位。5 2 1-5 2 -2。右移一位相当于整除 2。5 2无符号右移左边始终补 0。-5 2结果是很大的正数因为符号位被当成数值位一起移了。注意移位运算符只对 int 和 long 有效。如果你对 byte、short、char 做移位Java 会先把它提升为 int然后做移位。byte b 1; b 2的结果是 int不是 byte。还有一个冷知识int移位时移位位数会先对 32 取模。1 32等价于1 0结果是 1。因为 JVM 在底层使用了shift 0x1f针对 int来限制位移位数。这个行为在 Java 和 C 里是一致的但如果你预期的是“溢出变成 0”那就大错特错了。4.2 位运算的真实应用场景从 HashMap 到权限系统很多人觉得位运算在业务开发里用不上但 JDK 源码里全是位运算。以HashMap为例它的容量始终是 2 的幂次方为了实现快速取模它用的是(n - 1) hash而不是hash % n。为什么因为位运算比取模快得多。这就是为什么 HashMap 扩容后rehash的逻辑如此精妙。另一个常见场景是权限系统的位掩码。比如你有四个权限读1、写2、执行4、删除8用一个 int 就能把四个权限打包int READ 1 0; // 1 int WRITE 1 1; // 2 int EXEC 1 2; // 4 int DELETE 1 3; // 8 int userPermission READ | WRITE; // 3 boolean canWrite (userPermission WRITE) ! 0; // true这种写法在处理大量权限组合时非常优雅而且性能极高。我在做后台管理系统时经常用这种方式管理菜单权限一个int字段就把所有权限存进数据库了。4.3 异或运算的三条铁律异或运算有几个特性在算法题里极其常用a ^ 0 a任何数与 0 异或等于自身a ^ a 0任何数与自身异或等于 0异或满足交换律和结合律利用这三条可以在不使用临时变量的情况下交换两个整数int a 3, b 5; a a ^ b; // a 3 ^ 5 b a ^ b; // b 3 ^ 5 ^ 5 3 a a ^ b; // a 3 ^ 5 ^ 3 5还能在数组里找出唯一出现奇数次的数——把所有数全部异或一遍剩下的就是那个唯一没成对的数。这类题目在 LeetCode 上经常出现掌握了异或特性两三行代码就是最优解。5. 三元运算符与类型转换运算符写起来爽坑起来也爽5.1 三元运算符的类型自动提升问题三元运算符也叫条件运算符语法是条件表达式 ? 值1 : 值2。它本质是一个“表达式”有返回值可以被赋值。比如int max a b ? a : b。但三元运算符有一个大坑类型自动提升。看这段代码char gender 男; int age 30; Object result age 18 ? gender : age; // result 的值是 30004不是字符 男 或者数字 30因为三元运算符要求两个分支如果是基本类型会自动进行“二进制数值提升”。char和int会被提升为 int所以男的整数值 30004 被赋给了 result。这种隐式类型转换在代码评审时很难被发现尤其是分支类型是char、byte、short和int组合时。更隐蔽的是三元运算符和null结合时的空指针问题MapString, Integer map new HashMap(); Integer a null; Integer b 1; int result map ! null ? a : b; // NPE因为三元的整体类型被自动拆箱为 int这里的规则是如果两个操作数之一是int另一个是Integer整个表达式会被提升为int类型而Integer null拆箱时就抛NullPointerException。这个 bug 我在生产环境里遇到过排查了一个下午才知道是三元运算符合法拆箱惹的祸。5.2 类型转换运算符强转不是万能的类型转换运算符就是把一个类型强制转成另一个类型写法是在值前面加括号(int) 3.7。强制类型转换分为两种基本类型强转double转int会截断小数部分long转int会截断高位可能丢失数据。引用类型强转把父类对象转成子类类型如果实际对象不是该子类型运行时会抛ClassCastException。关于基本类型强转最经典的问题是int转byte。int i 200; byte b (byte) i;结果是-56。因为 int 的 200 是00000000 00000000 00000000 11001000转成 byte 只保留低 8 位11001000即十进制的 200但因为最高位是 1按补码解读就是 -56。这个知识点在面试里很常见但实际工作中较少直接用更多的是在读取二进制协议数据时才会遇到。引用类型强转的一个必要条件是“目标类型和实际类型之间有父子关系”否则编译器直接报错。如果你不确定实际类型最好先用instanceof检查if (obj instanceof String str) { // 现代 Java 的 pattern matching可以直接声明变量 }Java 16 以后支持instanceof的 pattern matching上面的写法比先判断再强转干净得多。5.3instanceof的边界判断instanceof运算符用于判断一个对象是不是某个类的实例包括子类、接口实现类。null instanceof AnyClass的结果是false这是规则不需要额外考虑空指针。有一个容易混淆的概念instanceof检查的是“实际对象类型”不是“引用的声明类型”。比如Object obj str; System.out.println(obj instanceof String); // true System.out.println(obj instanceof Object); // true因为obj实际指向的是 String 对象而 String 同时是 Object 的子类。6. 运算符优先级别再靠背了三个原则保平安6.1 优先级高低到底怎么排很多教材都会列一张很大的优先级表从()到赋值运算符十几行。我的建议是不用背记住几个关键节点就行。Java 运算符优先级从高到低的核心顺序后缀运算符expr、expr--、()、[]、.最高一元运算符expr、--expr、expr、-expr、~、!乘除*、/、%加减、-移位、、关系运算、、、、instanceof相等比较、!按位与按位异或^按位或|逻辑与逻辑或||三元运算符? :赋值运算符、等最低注意几个容易混淆的点的优先级高于^^高于|这三个都高于和||。所以a b c实际是a (b c)。还有移位运算符的优先级在加减之后所以1 2 3是(1 2) 3结果是 24不是1 (2 3)的 17。6.2 我的实战原则优先级规则即使记住了读代码时仍然容易出错。我的原则只有三条凡是有两个以上运算符的表达式一律用括号明确顺序。三元运算符嵌套超过一层改成 if-else 或 switch。位运算混入算术运算或比较运算时必须加括号。比如(num 1) 0判断 num 是不是偶数如果不加括号num 1 0会因为的优先级高于而被解析成num (1 0)编译直接报错。这个错误在代码评审里我见过好几次都是因为迷信自己的记忆力。7. 实操从零写一个带运算符优先级的简易计算器7.1 功能定义与思路拆解学运算符最好的方式不是背书而是写一个需要综合运用各类运算符的小程序。我建议初学者实现一个简易的整数四则运算计算器支持、-、*、/、%、括号并且正确处理运算符优先级。这个项目看似简单但要实现得干净实际上要用到栈和运算符优先级表。整体思路是将中缀表达式人类写的3 4 * 2转换为后缀表达式也叫逆波兰表达式3 4 2 * 使用调度场算法。对后缀表达式求值使用操作数栈。关键点需要一个比较运算符优先级的 map。这个项目能很好地检验你对运算符、栈、字符串处理的理解。而且它的扩展空间很大——从四则运算扩展到支持位运算、幂运算不过那已经是进阶玩法了。7.2 核心代码与实操注释先定义一个运算符优先级表和判断方法import java.util.HashMap; import java.util.Map; public class OperatorPrecedence { private static final MapCharacter, Integer PRECEDENCE new HashMap(); static { PRECEDENCE.put(, 1); PRECEDENCE.put(-, 1); PRECEDENCE.put(*, 2); PRECEDENCE.put(/, 2); PRECEDENCE.put(%, 2); } public static boolean isOperator(char c) { return PRECEDENCE.containsKey(c); } public static int comparePrecedence(char op1, char op2) { return PRECEDENCE.get(op1) - PRECEDENCE.get(op2); } }然后是中缀转后缀的核心方法import java.util.ArrayDeque; import java.util.Deque; public class InfixToPostfix { public static String convert(String expression) { StringBuilder output new StringBuilder(); DequeCharacter operators new ArrayDeque(); for (char ch : expression.toCharArray()) { if (Character.isDigit(ch)) { output.append(ch); } else if (ch () { operators.push(ch); } else if (ch )) { while (!operators.isEmpty() operators.peek() ! () { output.append( ).append(operators.pop()); } operators.pop(); // 弹出 ( } else if (OperatorPrecedence.isOperator(ch)) { while (!operators.isEmpty() operators.peek() ! ( OperatorPrecedence.comparePrecedence(operators.peek(), ch) 0) { output.append( ).append(operators.pop()); } output.append( ); operators.push(ch); } } while (!operators.isEmpty()) { output.append( ).append(operators.pop()); } return output.toString().trim(); } }最后是后缀表达式求值import java.util.ArrayDeque; import java.util.Deque; public class PostfixEvaluator { public static int evaluate(String postfix) { DequeInteger stack new ArrayDeque(); String[] tokens postfix.split( ); for (String token : tokens) { if (token.isEmpty()) { continue; } if (Character.isDigit(token.charAt(0))) { stack.push(Integer.parseInt(token)); } else { int operator1 stack.pop(); int operator2 stack.pop(); switch (token.charAt(0)) { case - stack.push(operator2 operator1); case - - stack.push(operator2 - operator1); case * - stack.push(operator2 * operator1); case / - stack.push(operator2 / operator1); case % - stack.push(operator2 % operator1); default - throw new IllegalArgumentException(非法运算符: token); } } } return stack.pop(); } }这段代码里switch -的箭头语法是 Java 14 以后的新特性更简洁。你用传统冒号写法也可以。需要注意的坑operator2和operator1的顺序。后缀表达式的计算里先出栈的是右操作数。switch里用operator2 operator1来保证5 3 -计算的是5 - 3而不是3 - 5。表达式里没有空格时Character.isDigit(ch)的处理逻辑会失效。我这里为了示例简单假设输入数字都是个位数如果要支持多位数需要加缓冲去拼接连续数字。我建议完整版直接枚举String的每个字符遇到数字就扫描到非数字为止。7.3 实测验证与边界情况测试3 4 * 2转换后后缀表达式3 4 2 * 求值结果11符合预期。测试(3 4) * 2转换后3 4 2 *求值结果14符合预期。测试7 - 2 * 3转换后7 2 3 * -求值结果1符合7 - 6。边界情况空表达式split( )会得到[]循环里直接continue跳过。除以零PostfixEvaluator里7 / 0会抛ArithmeticException这是正常的建议在 UI 层统一捕获并提示。非法字符比如输入字母aCharacter.isDigit(token.charAt(0))为 false但也不是运算符会走到default分支抛异常。这里有个小 bug 风险如果 token 是负数比如后缀表达式里出现-3我的代码会把它当成运算符然后在stack.pop()时因为栈为空抛异常。所以完整的计算器还需要单独处理负数。我的建议是通过正则把字符串里的负号识别成一元运算符来处理但这就复杂了需要单独一篇来写。8. 高频面试题与避坑技巧速查表8.1 面试八股文中的运算符考点我整理了近两年 Java 面试里出现频率极高的运算符相关题目每道题背后都藏着至少一个容易忽略的细节问题答案要点i和i的区别先取值后自增 vs 先自增后取值字节码层面是局部变量表和操作数栈的配合和的区别短路 vs 不短路 两侧都会执行和equals的区别基本类型比较值、引用类型比较地址equals可以被重写String 默认比较内容int和Integer比较用的坑缓存范围-128~127超出范围用equals整数除法7 / 2等于几3直接丢弃小数向零取整-7 % 2等于几-1结果符号跟随被除数三元运算符的自动拆箱 NPE一个分支是int、另一个是Integer且为 null 时会 NPE复合赋值运算符的强转s 1等价于s (short)(s 1)位运算和 的优先级HashMap 为什么用(n - 1) hash当 n 是 2 的幂时与运算等价于取模但更快8.2 实战避坑清单以下是我这几年写代码、做代码评审时真正遇到过的坑每一个都让某个同事debug到怀疑人生检查浮点位运算不要直接用0.1 0.2 0.3的结果是 false。用Math.abs(a - b) 1e-9或者用 BigDecimal。switch和三元运算符结合时注意类型提升int a flag ? 1 : 2.0编译报错因为 1 会被提升为 double。不要依赖复合赋值运算符的强转特性long a Integer.MAX_VALUE; a 1;没问题但int b Integer.MAX_VALUE; b 1;会溢出为负数这种 bug 不报错最难排查。取余运算结果可能为负在做循环队列、哈希表下标计算时务必用((index % size) size) % size。位运算和逻辑运算混写必须加括号(num 1) 0不要写成num 1 0。BigDecimal构造器用字符串不要用doublenew BigDecimal(0.1)会有精度问题new BigDecimal(0.1)才是正确的。不要在字符串拼接上使用到一万次以上s a每次都会创建新 String 对象性能极差。用StringBuilder或StringBuffer。9. 写在最后运算符不止是语法更是 JVM 的底层逻辑这篇文章从运算符的分类、核心规则、优先级一路写到了简易计算器的实现和面试高频题。我尽量把每个知识点背后“为什么”的部分都挖出来了因为只有理解了原理才能真正记住规则。比如i i为什么等于 3如果你只背结论下次遇到j i i这种题照样懵但如果你理解了局部变量表和操作数栈这类题就是送分题。我个人在实际备课和带新人的过程中最深刻的体会是运算符这块内容看上去很基础但它其实是连接“Java 语法”和“JVM 字节码”的一座桥。搞清楚i的字节码指令你对 JVM 的理解就不再局限于书上的名词搞清楚HashMap为什么用位运算做取模你才算真正读懂了 JDK 源码。所以别嫌这些知识点简单越基础的东西越值得往深里挖。最后再分享一个小技巧我建议你用 IDEA 的Show Bytecode插件或者配合javap -c命令去反编译自己写的运算符表达式代码。当你亲眼看到i变成iload、iinc、istore三条指令时你对运算符的理解会提升一个维度。这比把教材看十遍都有用。