从基础概念到高级技巧,全面解析Java运算体系
在Java语言体系中,运算是构建一切逻辑表达的基础。所谓java运算用法,是指开发者如何使用各类运算符组合出符合语义、高效可靠的表达式,以完成数据计算、逻辑判断、状态迁移等核心功能。Java运算体系覆盖算术、关系、逻辑、位、赋值、三元、条件等七大类运算符,每类均具备其特定的语法规范与使用场景。掌握其本质,是写出健壮、可维护Java代码的基石。
值得注意的是,Java对运算精度、溢出行为、短路求值等均有严格定义。例如:整数除法自动截断小数部分;0 / 0会抛出异常,而0.0 / 0.0结果为NaN;&&与||具备短路特性,而&与|则不会。这些细节虽小,却直接影响程序行为的正确性与安全性。
本页将系统梳理各类运算符的语法、语义、典型用法、常见陷阱及性能优化策略,并结合真实代码案例,帮助开发者构建完整的运算认知框架。内容不仅适用于初学者建立正确认知,亦为资深工程师提供查漏补缺与最佳实践参考。
| 类型 | 运算符 | 说明 | 示例 |
|---|---|---|---|
| 算术 | + - * / % ++ -- |
执行基本数学运算 | int a = 7 % 3; // 2 |
| 关系 | == != > < >= <= |
比较两个值的大小关系 | boolean b = (5 > 3); // true |
| 逻辑 | & && | || ! ^ |
组合或取反布尔表达式 | boolean c = (x>0 && y<10); |
| 位运算 | & | ^ ~ << >> >>> |
对整数二进制位进行操作 | int d = 5 << 2; // 20 |
| 赋值 | = += -= *= /= %= |
将值赋给变量(含复合赋值) | x += 3; // x = x + 3 |
| 三元 | ? : |
条件表达式,三目运算 | int max = (a > b) ? a : b; |
| 其他 | instanceof . [] new |
类型判断、成员访问、数组索引、创建对象 | obj instanceof String |
以上分类并非孤立存在,实际开发中常需组合使用。例如:if ((arr != null) && (arr.length > 0)) { ... }中同时涉及逻辑&&、关系>与成员访问.运算。因此理解运算符的组合逻辑与求值顺序至关重要。
java运算用法中的算术运算符包括:+(加)、-(减)、*(乘)、/(除)、%(取模/求余)、++(自增)、--(自减)。它们支持整型、浮点型及字符串拼接。
Java中整数除法结果为整数(截断小数),取模结果符号与被除数一致:
int a = 7 / 3; // 2(截断小数部分) int b = -7 / 3; // -2 int c = 7 % -3; // 1(被除数为正) int d = -7 % 3; // -1(被除数为负)
此行为符合ISO/IEC 9899标准(C语言),但与Python不同(Python中-7 % 3 = 2),初学者易混淆,需特别注意。
++i(前缀):先自增,再参与运算;i++(后缀):先参与运算,再自增。
int i = 5; int a = ++i; // i=6, a=6 int b = i++; // b=6, i=7
在循环或链式表达式中,误用前/后缀是常见bug来源。例如:
int[] arr = {1,2,3};
int i = 0;
System.out.println(arr[i++]); // 输出1,i变为1
+在至少一边为字符串时执行拼接,否则执行加法。若表达式中存在字符串,则后续所有+均视为拼接:
System.out.println(1 + 2 + "3"); // "33"
System.out.println("1" + 2 + 3); // "123"
System.out.println("1" + (2 + 3)); // "15"
括号可强制改变运算顺序,避免隐式类型提升导致的逻辑错误。在构建日志或JSON时,应优先使用String.format()或StringBuilder以提升性能与可读性。
Integer.MAX_VALUE + 1结果为Integer.MIN_VALUE。如需安全运算,应使用Math.addExact()、Math.multiplyExact()等方法。
Java整数类型有固定范围:byte(-128~127)、short(-32768~32767)、int(-2³¹~2³¹-1)、long(-2⁶³~2⁶³-1)。超出范围即溢出,结果回绕(wrap-around):
int max = Integer.MAX_VALUE; int overflow = max + 1; // -2147483648 System.out.println(overflow);
此类错误在时间戳计算、数组索引、计数器中极易发生。例如:计算用户总数时,若超过21亿,将变为负数,导致逻辑崩溃。
解决方案:
Math.addExact()、Math.multiplyExact()等方法,溢出时抛出ArithmeticExceptionlong类型存储大整数(注意:long仍可能溢出)BigInteger整数除零抛出ArithmeticException,浮点除零则返回特殊值:
int a = 5 / 0; // 抛出 ArithmeticException: / by zero double b = 5.0 / 0; // Infinity double c = 0.0 / 0; // NaN(Not a Number)
在金融、科学计算中,NaN会传播:任何与NaN的运算结果均为NaN,且NaN == NaN为false,需用Double.isNaN()检测。
防御性编程建议:
Optional封装可能失败的运算结果isNaN()与isInfinite()校验IEEE 754浮点数存储方式导致精度损失。例如:
double x = 0.1 + 0.1 + 0.1; System.out.println(x == 0.3); // false System.out.println(x); // 0.30000000000000004
根本原因:0.1无法被二进制精确表示,其二进制为无限循环小数,截断后存在舍入误差。
解决方案:
Math.abs(a - b) < 1e-9BigDecimal,并指定精度与舍入模式:BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal c = a.add(b); // 精确为 0.3
double构造BigDecimal(应使用字符串):new BigDecimal(0.1) ≠ new BigDecimal("0.1")
关系运算符包括:==(等于)、!=(不等于)、>(大于)、<(小于)、>=(大于等于)、<=(小于等于)。它们返回布尔值,是条件判断与循环控制的核心。
==比较的是引用地址(对象)或数值(基本类型),而equals()是Object类的方法,可被重写以实现自定义逻辑。
String a = new String("hello");
String b = new String("hello");
System.out.println(a == b); // false(不同对象)
System.out.println(a.equals(b)); // true(内容相同)
对于包装类型(Integer、Double等),==同样比较引用地址,但JDK对-128~127范围内的值做了缓存:
Integer x = 100; Integer y = 100; System.out.println(x == y); // true(缓存复用) Integer m = 200; Integer n = 200; System.out.println(m == n); // false(超出缓存范围)
正确做法:比较包装类型数值时,始终使用equals()或compareTo(),除非明确需要地址比较。
直接使用==比较字符串字面量可能“偶然正确”,但不可靠:
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true(字符串常量池复用)
String s3 = new String("hello");
System.out.println(s1 == s3); // false
所有字符串内容比较应使用equals(),忽略大小写时用equalsIgnoreCase()。
当变量可能为null时,直接调用equals()会抛出NullPointerException。安全写法:
// 方式1:常量在前
if ("admin".equals(username)) { ... }
// 方式2:Objects.equals()(JDK7+)
if (Objects.equals(user, null)) { ... }
// 方式3:Objects.equals() 双向安全
Objects.equals(a, b); // a或b为null时返回false,二者均为null时返回true
推荐统一使用Objects.equals(),避免手写空指针检查,提升代码健壮性。
逻辑运算符包括:&(逻辑与)、|(逻辑或)、^(逻辑异或)、!(逻辑非)、&&(短路与)、||(短路或)。
&&与||具备短路特性:当左侧表达式已能确定结果时,右侧不再求值。
boolean a = (x != null) && x.isValid(); // x为null时,x.isValid()不执行 boolean b = (list.size() > 0) || expensiveCheck(); // list非空时,expensiveCheck()不执行
若误用&或|,会导致不必要的方法调用甚至空指针异常:
boolean c = (x != null) & x.isValid(); // x为null时,仍执行x.isValid() → NPE
^表示“异或”:相同为false,不同为true。典型用途:
a = a ^ b; b = a ^ b; a = a ^ b;(n & 1) == 0等价于n % 2 == 0,但位运算更快plain ^ key = cipher; cipher ^ key = plain逻辑运算符与位运算符同名(如&与&&),但作用对象不同:
&:按位与(如5 & 3 = 1,二进制101 & 011 = 001)|:按位或(如5 | 3 = 7)^:按位异或(如5 ^ 3 = 6)常用于权限控制、状态标记、掩码提取等场景:
int PERMISSION_READ = 1 << 0; // 001 int PERMISSION_WRITE = 1 << 1; // 010 int PERMISSION_EXEC = 1 << 2; // 100 int userPerms = PERMISSION_READ | PERMISSION_WRITE; // 011 boolean canRead = (userPerms & PERMISSION_READ) != 0; // true boolean canExec = (userPerms & PERMISSION_EXEC) != 0; // false
位运算符直接操作整数的二进制位:&(与)、|(或)、^(异或)、~(非)、<<(左移)、>>(右移)、>>>(无符号右移)。
左移n位相当于乘2ⁿ(注意溢出);右移n位相当于除2ⁿ(向下取整):
int a = 5 << 2; // 20(5 × 4) int b = 20 >> 2; // 5(20 ÷ 4)
右移保留符号位(>>),无符号右移补零(>>>),后者对负数结果不同:
int c = -8; System.out.println(c >> 2); // -2(11111111...11000 → 11111111...11110) System.out.println(c >>> 2); // 1073741822(高位补0)
使用位掩码可紧凑存储多个布尔状态,节省内存并提升性能:
int FLAG_A = 1 << 0; // 0001 int FLAG_B = 1 << 1; // 0010 int FLAG_C = 1 << 2; // 0100 int FLAG_D = 1 << 3; // 1000 int flags = FLAG_A | FLAG_C; // 0101(A和C启用) // 添加状态 flags |= FLAG_B; // 0111 // 移除状态 flags &= ~FLAG_C; // 0011 // 检查状态 boolean hasA = (flags & FLAG_A) != 0; // true
| 目标 | 位运算表达式 | 说明 |
|---|---|---|
| 取最低位 | n & 1 |
判断奇偶:0偶,1奇 |
| 清零最低位 | n & (n - 1) |
将最低位的1置0(如12→8) |
| 保留最低位 | n & -n |
提取最低位的1(如12→4) |
| 计算2的幂 | 1 << k |
结果为2k |
| 判断是否为2的幂 | (n & (n-1)) == 0 && n > 0 |
2的幂二进制仅一个1 |
位运算性能极高,常用于底层开发(如Netty、JDK源码),但可读性较差,需合理注释。
三元运算符? :是Java中唯一的三目运算符,语法为:条件 ? 表达式1 : 表达式2。当条件为真时返回表达式1,否则返回表达式2。
int max = (a > b) ? a : b; String grade = score >= 90 ? "A" : (score >= 80 ? "B" : "C");
嵌套虽可减少代码行数,但会降低可读性。建议:逻辑复杂时改用if-else。
三元运算符要求两个分支表达式类型兼容。若类型不同,编译器会尝试提升为共同父类型:
Object obj = true ? "hello" : 123; // 结果为String(提升为Serializable & Comparable) Object obj2 = true ? "hello" : Integer.valueOf(123); // 结果为Serializable
若分支类型为包装类型与基本类型,可能出现自动拆箱导致NPE:
Integer a = null; Integer b = 10; Integer c = true ? a : b; // 编译通过,运行时拆箱a → NPE
解决方案:确保分支类型一致,或显式包装:
Integer c = true ? a : Integer.valueOf(b); // 仍可能NPE Integer c = (a != null) ? a : b; // 更安全
编译后两者字节码几乎相同,性能无差异。选择标准应为:可读性优先。简单赋值用三元,多语句逻辑用if-else。
Java运算符优先级决定表达式求值顺序。高优先级先计算,同级从左到右(除赋值与三元从右到左)。
() [] . instanceof(括号、数组索引、成员访问、类型判断)
++ -- ! ~ (type)(自增/自减、逻辑非、按位非、强制类型转换)
* / %
+ -(注意:字符串拼接也用+,但优先级低于算术运算)
<< >> >>>
< > <= >= instanceof
== !=
&
^
|
&&
||
? :
= += -= *= /= %= &= |= ^= <<= >>= >>>=
int x = 5; int y = 3; int z = x + y * 2; // 11(先乘后加) int w = (x + y) * 2; // 16(强制先加) boolean a = true || false && false; // true(&&优先级高于||) boolean b = true || (false && false); // true boolean c = (true || false) && false; // false
建议:复杂表达式加括号,避免依赖优先级记忆,提升可读性。
Java中,byte、short、char参与运算时自动提升为int:
byte a = 10; byte b = 20; // byte c = a + b; // 编译错误:不兼容的类型:从int到byte可能有损失 byte c = (byte)(a + b); // 显式强制转换
此设计源于JVM指令集(仅支持int运算),开发者易忽略导致编译失败。
自动装箱(基本类型→包装类型)与拆箱(包装类型→基本类型)虽方便,但存在风险:
Integer a = null; int b = a; // 拆箱a → NullPointerException
循环中频繁装箱拆箱影响性能:
// 低效:每次循环创建新Integer对象
Integer sum = 0;
for (int i = 0; i < 1000; i++) {
sum += i; // 自动拆箱 + 加法 + 自动装箱
}
优化方案:循环内用基本类型,最后再转换:
int sum = 0;
for (int i = 0; i < 1000; i++) {
sum += i;
}
Integer result = sum; // 仅一次装箱
在循环中使用+拼接字符串,每次都会创建新String对象,性能极差:
// 低效:O(n²)时间复杂度
String result = "";
for (int i = 0; i < 1000; i++) {
result += i + ",";
}
正确做法:使用StringBuilder(单线程)或StringBuffer(多线程):
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append(i).append(",");
}
String result = sb.toString();
JDK 8+ 中,编译器会自动优化简单拼接为StringBuilder,但循环内仍需手动使用。
&&与||替代&与|(除非明确需要位运算),避免无效计算与空指针。
Objects.equals(a, b)安全处理null,且支持任意类型。
BigDecimal,并指定RoundingMode。
// 0x01: 可读, 0x02: 可写)。
boolean isValid = (x > 0) && (y < 10);),提升可读性。
Math.addExact()、Math.multiplyExact()等可捕获溢出。