Java运算符大全（附运算符优先级表，非常详细）
运算符是用来表示某一种运算的符号，它指明了对操作数所进行的运算。操作数是指运算的对象，可以是变量、常量或表达式。将操作数和运算符结合起来的计算式称为表达式。
Java 语言涉及多种运算符，这些运算符按照操作数的数目不同可以分为 3 种，分别是一元运算符、二元运算符和三元运算符；按照运算的性质不同则可分为 7 种，分别是算术运算符、关系运算符、逻辑运算符、赋值运算符、位运算符、条件运算符、其他运算符（下标运算符[]、实例运算符instanceof、分量运算符->等）。
下标运算符、实例运算符和分量运算符的用法，我会在《Java基础教程（从入门到精通）》中讲解到相关的知识点时做详细介绍。
Java算术运算符
算术运算符是用来执行一般的数学运算的符号，这类运算符是最基本、最常见的，作用于整数类型、浮点类型数据，用来完成相应的算术运算。
Java 语言的算术运算符可以分为一元运算符和二元运算符。一元运算符只有一个操作数参与运算，二元运算符则有两个操作数参与运算。
一元运算符
一元算术运算符有 4 种，如下表所示。
表：一元算术运算符
运算符
运算
用法
功能描述
+
正号
+a
正号起类型提升作用
-
负号
-a;
取相反数
++
加1
b = a++
先赋值给其他变量，再加 1
++
加1
b = ++a
先加 1，再赋值给其他变量
--
减1
b = a--
先赋值给其他变量，再减 1
--
减1
b = --a
先减 1，再赋值给其他变量
针对自增运算符（++）和自减运算符（--），写在变量后面的为后置式，写在变量前面的为前置式。二者的区别在于：后置式是先将值赋值给接受的其他变量，然后再加 1（减 1），前置式是先加 1（减 1），然后再将变量的值赋值给其他变量。
接下来，通过案例来演示一元算术运算符的使用：
public class Demo {
public static void main(String[] args) {
System.out.println("---------正号/负号-----------");
short a = 22;
//short b = +a; // 正号起类型提升作用
int d = +a;
int e = -d; // 负号取反
System.out.println("d=" + d);
System.out.println("e=" + e);
System.out.println("---------自增/自减运算符-----------");
int i = 11; // 声明i为整数类型，初始值为11
System.out.println("i=" + i);
int j = i++;
// 自增运算符为后置式
System.out.println("j=i++ i=" + i + ", j=" + j);
j = ++i;
// 自增运算符为前置式
System.out.println("j=i++ i=" + i + ", j=" + j);
j = i--;
// 自减运算符为后置式
System.out.println("j=i-- i=" + i + ", j=" + j);
j = --i;
// 自减运算符为前置式
System.out.println("j=i-- i=" + i + ", j=" + j);
}
}
程序的运行结果如下：
标准输出：---------正号/负号-----------
d=22
e=-22
---------自增/自减运算符-----------
i=11
j=i++ i=12, j=11
j=i++ i=13, j=13
j=i-- i=12, j=13
j=i-- i=11, j=11
如果不将第 5 行代码注释掉，则会编译报错，原因是在 byte 类型的变量 a 前面加了“+”号，表示将其类型提升为了 int 类型，所以报错。但是，第 6 行使用 int 类型的变量 d 来接收，则不会报错。
第 13 行代码中，因为 i++ 的自增运算符为后置式，所以会先将 i 变量值 11 赋值给变量 j，然后 i 变量加 1，执行后结果为 i = 12，j = 11。
第 16 行代码中，因为 ++i 的自增运算符为前置式，所以会先将 i 变量先加 1，然后再赋值给 j 变量，执行后结果为 i = 13，j = 13。
第 19 行代码中，因为 i-- 的自减运算符为后置式，所以会先将 i 变量值 13 赋值给变量 j，然后 i 变量减 1，执行后结果为 i = 12，j = 13。
第 22 行代码中，因为 --i 的自减运算符为前置式，所以会先将 i 变量减 1，再赋值给 j 变量，执行后结果为 i = 11，j = 11。
二元运算符
Java 中的二元算术运算符有 5 种，如下表所示：
表：二元算术运算符
运算符
运算
用法
功能描述
+
加
a + b
求 a 加 b 的和
-
减
a - b
求 a 减 b 的差
*
乘
a * b
求 a 乘以 b 的积
/
除
a / b
求 a 除以 b 的商
%
取模
a % b
求 a 除以 b 的余数
对于上述二元算术运算符，需要特别注意以下几点：
对于除法运算符“/”，若两个整数之间做除法，则计算结果也是整型，除数不能为 0；若两个操作数只要有一个是浮点数，则计算结果也是浮点数。
取模运算符“%”也称为求余运算符，其操作数可以是浮点数。只有单精度操作数的浮点表达式按照单精度运算求值，结果是单精度；如果包含一个或一个以上的双精度操作数，则按双精度运算，结果是双精度。运算结果的正负取决于被取模数（被除数）的符号，与模数（除数）的符号无关。
加法运算符“+”可用于字符串连接符。Java 语言针对“+”号运算符进行了扩展，使它可以进行字符串的拼接，如“hi”+“boy”，得到就是字符串“hiboy”。
接下来，通过案例来演示二元算术运算符的使用：
public class Demo {
public static void main(String[] args) {
int a = 66, b = 9;
System.out.println("-----算术运算符和算术表达式案例-----");
System.out.println(a + "+" + b + "=" + (a + b));
System.out.println(a + "-" + b + "=" + (a - b));
System.out.println(a + "*" + b + "=" + (a * b));
System.out.println(a + "/" + b + "=" + (a / b));
System.out.println(a + "%" + b + "=" + (a % b));
}
}
程序的运行结果如下：
标准输出：-----算术运算符和算术表达式案例-----
66+9=75
66-9=57
66*9=594
66/9=7
66%9=3
程序中，使用算术运算符 +、-、*、/、% 进行了算术计算，优先计算小括号内的表达式。
第 8 行代码中，因为两个变量都为整数类型，且 66/9 无法整除，所以会将小数点以后的位数省略，结果为 7；如果要保留小数点以后的位数，则必须声明变量 a 和 b 为浮点数据类型。
算术混合运算的精度
在 Java 程序开发中，经常会遇到混合运算。在混合运算中，常常会出现精度丢失现象，主要表现如下：
从大的数据类型向小的数据类型转化的过程中，可能会出现精度丢失；
浮点数在进行混合运算的过程中可能会有精度丢失的情况。
接下来，通过案例来演示算术混合运算精度丢失的情况，
public class Demo {
public static void main(String[] args) {
char c1 = 'a';
int num1 = c1;
System.out.println("num1=" + num1);
System.out.println("0.05+0.1+1=" + (0.05 + 0.1 + 1));
System.out.println("1.0-0.42+1=" + (1.0 - 0.42 + 1));
System.out.println("0.05+0.1=" + (0.05 + 0.1));
System.out.println("1.0-0.42=" + (1.0 - 0.42));
}
}
程序的运行结果如下：
标准输出：num1=97
0.05+0.1+1=1.15
1.0-0.42+1=1.58
0.05+0.1=0.15000000000000002
1.0-0.42=0.5800000000000001
第 4 行代码针对 char 类型的变量 c1 进行了提升，输出为 97，即 c1 在计算中对应的 ASCII 码。
第 6 行和第 7 行代码有浮点数和整数参与运算，输出内容正确。但是，第 8 行和第 9 行代码只有浮点数进行运算，计算结果则出现误差，这是 CPU 所采用的浮点数计数法造成的。
float 和 double 的精度是由尾数的位数来决定的，其整数部分始终是一个隐含着的“1”，由于它是不变的，故不能对精度造成影响：
float：2^23 = 8388608，一共 7 位，由于最左为 1 的一位省略了，这意味着最多能表示 8 位数，即 2*8388608 = 16777216。有 8 位有效数字，但绝对能保证的为 7 位，也即 float 的精度为 7~8 位有效数字。
double：2^52 = 4503599627370496，一共 16 位。同理，double 的精度为 16~17 位。例如，对于 double 类型 0.3 - 0.1 的情况，需要将两个操作数转换成二进制再进行运算，0.3 转换后的结果为 0.0100110011001100110011001100110011001100110011001101，但是因为超出计算精度，最多保留 16 位，所以最终结果为 0.0100110011001100，这就是导致计算结果出现误差的原因。
因此，Java 的浮点类型只能用来进行科学计算或工程计算，在大多数的商业计算中，一般采用 java.math.BigDecimal 类来进行精确计算。针对上述问题，可以修改为如下代码：
BigDecimal b1 = BigDecimal.valueOf(0.05);
BigDecimal b2 = BigDecimal.valueOf(0.1);
BigDecimal b3 = BigDecimal.valueOf(1.0);
BigDecimal b4 = BigDecimal.valueOf(0.42);
System.out.println(b1.add(b2));
System.out.println(b3.subtract(b4));
修改之后的输出结果如下：
0.15
0.58
Java关系运算符
关系运算符又叫比较运算符，用于比较两个操作数之间的关系，其运算的结果是一个布尔值，即 true 或 false，经常用于控制语句（条件语句或循环语句）中。
Java中的关系运算符和使用示例，如下表所示。
表：关系运算符
运算符
运算
示例
结果
==
等于
2 == 3
false
!=
不等于
2 != 3
true
<
小于
2 < 3
true
<=
小于等于
2 <= 3
true
>
大于
2 > 3
false
>=
大于等于
2 >= 3
false
除“==”运算符外，其他关系运算符都只支持左右两边的操作数都是数值类型。基本数据类型变量、常量不能和引用类型的变量、常量使用“==”进行比较，如果引用数据类型之间没有继承关系，也不能使用“==”进行比较。
接下来，通过案例来演示关系运算符的使用：
public class Demo {
public static void main(String[] args) {
int num1 = 39, num2 = 80;
System.out.println("-------关系运算符和关系表达式案例-------");
System.out.println("num1 == num2 = " + (num1 == num2));
System.out.println("num1 != num2 = " + (num1 != num2));
System.out.println("num1 > num2 = " + (num1 > num2));
System.out.println("num1 < num2 = " + (num1 < num2));
System.out.println("num1 >= num2 = " + (num1 >= num2));
System.out.println("num1 <= num2 = " + (num1 <= num2));
}
}
程序的运行结果如下：
标准输出：-------关系运算符和关系表达式案例-------
num1 == num2 = false
num1 != num2 = true
num1 > num2 = false
num1 < num2 = true
num1 >= num2 = false
num1 <= num2 = true
程序中，使用关系运算符进行了关系表达式计算，优先计算小括号内的表达式。第 9 行和第 10 行代码使用了关系运算符“>=”和“<=”，表示大于或等于、小于或等于二者符合一个条件即可返回 true，否则返回 false，因为 num1 小于 num2，所以第 9 行返回值为 false，第 10 行返回值为 true。
注意，关系运算符是一个整体，==、>=、<=、!= 不可以在中间插入空格，如“==”是对的，而“= =”是错的。
Java逻辑运算符
逻辑运算符用于对布尔类型的值或者表达式进行操作，其结果仍然是一个布尔值。换句话说，布尔类型的值与逻辑运算符构成逻辑表达式，其值是一个布尔值，而一个或多个关系表达式还可以进行逻辑运算，其值仍然是一个布尔值。
Java 中的逻辑运算符和使用示例，如下表所示：
表：逻辑运算符
运算符
运算
示例
结果
&
与
a & b
a、b 均为 true 时，结果才为 true
|
或
a | b
a、b 均为 false 时，结果才为 false
^
异或
a ^ b
a、b 操作数不同时，结果为 true，相同时为 false
!
非
! a
将操作数 a 取反
&&
短路与
a && b
a、b 均为 true 时，结果才为 true
||
短路或
a || b
a、b 均为 false 时，结果才为 false
逻辑运算符中 & 和 &&、| 和 || 的运算结构都相同，区别在于 && 和 || 属于短路运算，也称为简洁运算，只需要执行逻辑运算符左侧表达式即可，无须计算右侧表达式，这样可以加快执行效率。当使用 & 和 | 时，必须计算左右两个表达式之后，才能决定运算结果。
例如，当进行 & 逻辑运算时，必须两侧的值都是 true，其结果才是 true，若其中一个是 false，结果就为 false；而对于 && 逻辑运算，只要左侧表达式为 false，其结果就是 false，之后的值就不再进行判断；对于 ||，只要左侧表达式为 true，其结果就是 true，之后的值不再做判断。
^ 表示异或运算，两个操作数结果相同则为 false，两个操作数结果不同则为 true，可以使用“两值相异即为真；两值相同即为假”来简记。
接下来，通过案例来演示逻辑运算符的使用：
public class Demo {
public static void main(String[] args) {
int num1 = 11, num2 = 9, num3 = 22;
System.out.println("-------逻辑运算符和逻辑表达式案例-------");
System.out.println(!(num1 > num2));
System.out.println((num1 > num3) & (num1 > num2));
System.out.println((num1 > num3) && (num1 > num2));
System.out.println((num1 > num2) || (num1 > num3));
System.out.println((num1 > num2) | (num1 > num3));
System.out.println((num1 > num2) ^ (num1 > num3));
}
}
程序的运行结果如下：
标准输出：-------逻辑运算符和逻辑表达式案例-------
false
false
false
true
true
true
程序中，第 5 行代码中 num1 > num2 结果为 true，取反后结果为 false。
第 6 行代码“&”符号两边逻辑表达式都要执行，第 1 个表达式结果为 false，第 2 个表达式结果为 true，运算后结果为 false。
第 7 行代码，第 1 个表达式结果为 false，因为“&&”为短路运算，第 2 个表达式不会执行；第 8 行代码第 1 个表达式结果为 true，因为“||”为短路运算，第 2 个表达式不会执行。
第 9 行代码中，两个表达式都要判断，第 1 个结果为 true，第 2 个结果为 false，所以结果为 true。
第 10 行代码，因为两个表达式结果不同，执行异或操作，所以结果为 true。
Java赋值运算符
赋值运算符就是将常量、变量、表达式的值赋给某一个变量或对象，赋值表达式由变量、赋值运算符和表达式组成。赋值运算符包括“=”赋值运算符和扩展赋值运算符两种。
Java 中的赋值运算符和使用示例，如下表所示：
表：赋值运算符
运算符
运算
示例
结果
=
赋值
a = 5; b = 2;
a = 5; b = 2;
+=
加等于
a = 5; b = 2; a += b;
a = 7; b = 2;
-=
减等于
a = 5; b = 2; a -= b;
a = 3; b = 2;
*=
乘等于
a = 5; b = 2; a *= b;
a = 10; b = 2;
/=
除等于
a = 5; b = 2; a /= b;
a = 2; b = 2;
%=
模等于
a = 5; b = 2; a %= b;
a = 3; b = 2;
赋值语句的结果是将右侧的值（或表达式结果）赋给左边的变量。
变量在进行普通赋值时，如果赋值运算符两侧的类型彼此不一致，或者左边类型取值范围小于右边类型时，需要进行自动或强制类型转换。也就是说，变量从占用内存较少的短数据类型转换为占用内存较多的长数据类型时，会自动进行隐式转换；而将变量从较长的数据类型转换为较短的数据类型时，则必须进行强制类型转换，也就是采用“(类型)表达式”。
赋值运算符也可以采取右端表达式继续赋值的方式，形成连续赋值的情况，但是一般不建议使用该方式进行赋值，会降低程序的可读性。
赋值运算符的使用示例如下：
int n = 5; // 声明并赋值
int a, b, c; // 连续声明
a = b = c = 5; // 多个变量同时赋值，表达式等价于c = 5;b = c;a = b;
int a = 1;
byte b = 3;
b = a + b; // 错误，将int类型赋值给byte类型变量需要强制转换
b = (byte)(a + b); // 正确
在赋值运算符“=”前加上其他运算符，即构成扩展赋值运算符，如a += 7等价于a = a + 7。也就是说，扩展赋值运算符是先进行某种运算之后，再对运算的结果进行赋值。
扩展赋值运算符的优点是可以使程序表达简洁，并且能提高程序的编译速度。编译器首先会进行运算，再将运算结果赋值给变量。具体示例如下：
int a = 3; // 声明变量a
a += 1; // a = 4;等价于a = a + 1;
a *= 2; // a = 6;等价于a = a * 2;
接下来，通过案例来演示赋值运算符的使用：
public class Demo {
public static void main(String[] args) {
int a, b, c; // 声明变量a、b、c
a = 18; // 将18赋值给变量a
c = b = a - 9; // 将a与9的差赋值给变量b，然后再赋值给变量c
System.out.println("-------赋值运算符和赋值表达式案例-------");
System.out.println("a=" + a + ",b=" + b + ",c=" + c);
a += c; // 相当于a = a + c
System.out.println("a+=c;a=" + a);
a -= c; // 相当于a = a - c
System.out.println("a-=c;a=" + a);
a *= c; // 相当于a = a * c
System.out.println("a*=c; a=" + a);
a /= c; // 相当于a = a / c
System.out.println("a/=c; a=" + a);
a %= c - 2; // 相当于a = a % c - 2
System.out.println("a%=c-2;a=" + a + ",c=" + c);
}
}
程序的运行结果如下：
--------赋值运算符和赋值表达式案例--------
a=18,b=9,c=9
a+=c;a=27
a-=c;a=18
a*=c; a=162
a/=c; a=18
a%=c-2;a=4,c=9
程序中，第 5 行代码使用了赋值运算符的连续赋值，先将差值赋值给 b，然后再赋值给 c。
第 8、10、12、14 行代码分别表示操作数 a 对 c 的相加后赋值、相减后赋值、相乘后赋值、相除后赋值。
第 16 行代码，先计算右侧 c-2，因为 c 的值是 9，所以右侧减 2 之后结果为 7，a 的值为 18，对 7 求余，结果为 4。
使用赋值运算符需要注意如下两点：
要注意数据类型匹配，如 boolean flag = 23 就是类型不匹配，无法自动转换。
不能为运算式赋值，如“int a = 8,b = 9;a + b = 28;”，这是语法错误。
Java位运算符
位运算符是对操作数以二进制（bit 比特）为单位进行操作和运算，使用在整型和字符类型数据上。
运算符可以利用屏蔽位置和置位技术来设置或获得一个数字中的单个位或几位，或者将一个位模式向右或向左移动。对于正数而言，最高位为 0，其余各位代表数值本身；对于负数而言，把该数绝对值的补码按位取反，然后对整个数加 1，即得到该数的补码。
位运算符包括位逻辑运算符和移位运算符。位逻辑运算符如下表所示：
表：位逻辑运算符
运算符
运算
示例
结果
&
按位与
a & b
将 a 和 b 按 bit 位相与
|
按位或
a | b
将 a 和 b 按 bit 位相或
~
取反
~a
将 a 按位取反
^
按位异或
a ^ b
将 a 和 b 按 bit 位相异或
若 x 和 y 相当于二进制中的某个位，其值只能取 0 或 1，针对 &、|、~、^ 这 4 种位运算符，其结果如下表所示：
表：位运算结果表
x
y
x & y
x | y
~x
x ^ y
0
1
0
1
1
1
1
0
0
1
0
1
1
1
1
1
0
0
0
0
0
0
1
0
位逻辑运算符只能操作整数类型的变量或常量。位逻辑运算的运算法则如下：
1) &是按位与运算符，参与按位与运算的两个操作数相对应的二进制位上的值同为 1，则该位运算结果为 1，否则为 0。
例如，将 byte 型的数值 5 与 8 进行按位与运算，5 对应二进制数为 0000 0101，8 对应二进制数为 0000 1000，运算结果为 0000 0000，对应数值 0。具体演算过程如下图所示：
图 1 &运算
2) |是按位或运算符，参与按位或运算的两个操作数相对应的二进制位上的值有一个为 1，则该位运算结果为 1，否则为 0。
例如，将 byte 型的数值 5 与 9 进行按位或运算，运算结果为 0000 1101，对应数值 13。具体演算过程如下图所示：
图 2 |运算
3) ~是取反运算符，是单目运算符，即只有一个操作数。二进制位值为 1，则取反值为 0；值为 0，则取反值为 1。
例如，将 byte 型的数值 9 进行取反运算，运算结果为 1111 0110，对应数值 -10。具体演算过程如下图所示：
图 3 ~运算
4) ^是按位异或运算符，参与按位异或运算的两个操作数相对应的二进制位上的值相同，则该位运算结果为 0，否则为 1。
例如，将 byte 型的常量 5 与 9 进行按位或运算，运算结果为 0000 1100，对应数值 12。具体演算过程如下图所示：
图 4 ^运算
移位运算符如下表所示：
表：移位运算符
运算符
运算
示例
结果
<<
左移
a << b
将 a 各 bit 位向左移 b 位
>>
右移
a >> b
将 a 各 bit 位向右移 b 位
>>>
无符号右移
a >>> b
将 a 各 bit 位向右移 b 位，左侧的空位填充 0
<<=
左移后赋值
a <<= n
将 a 按位左移 n 位，结果赋值给 a
>>=
右移后赋值
a >>= n
将 a 按位右移 n 位，结果赋值给 a
>>>=
左端补零右移后赋值
a >>>= n
将 a 无符号右移 n 位，结果赋值给 a
移位运算符是把一个二进制数值向左或向右按位移动。移位运算的运算法则如下。
1) <<是左移运算符，将操作数的二进制位整体向左移动指定位数，符号位保持不变，左边高位移出舍弃，右边低位的空位补 0。
例如，将 byte 型的数值 9 进行左移 3 位运算，运算结果为 0100 1000，对应数值 72。具体移位过程如下图所示：
图 5 <<运算
2) >>是右移运算符，将操作数的二进制位整体向右移动指定位数，符号位保持不变，右边低位移出舍弃，左边高位的空位补符号位，即正数补 0，负数补 1。
例如，将 byte 型的数值 8 进行右移 2 位运算，运算结果为 0000 0010，对应数值 2，具体移位过程如下图所示：
图 6 正数>>运算
再如，将 byte 型的数值 -9（二进制码为 9 的补码形式）进行右移 2 位运算，运算结果为 1111 1101，对应数值 -3（再次用补码形式），具体移位过程如下图所示：
图 7 负数>>运算
3) >>>是无符号右移运算符，将操作数的二进制位整体向右移动指定位数，符号位保持不变，右边低位移出舍弃，左边高位的空位补 0。因为正数符号位是 0，所以针对正数而言 >> 和 >>> 符号没有差别，主要是负数在使用 >>> 进行移位时，原来左边符号位需要补 1，现在换成了补 0。
这里需要特别注意，当将 byte 型的数值 -9 进行无符号右移 3 位运算时，按上述原理运算结果为 00011110，对应数值 30，但是实际输出数值 536870910。原因在于使用无符号右移运算符，对于低于 int 类型（byte、short 和 char）的操作数总是需要先转换为 int 类型，则 -9 的二进制数值为：
11111111111111111111111111110111
按位无符号右移 3 位后的二进制数值为：
00011111111111111111111111111110
对应的十进制是 536870910。
接下来，通过案例来演示位运算符的使用：
public class Demo {
public static void main(String[] args) {
byte a = 5, b = 8, c = 9, d = -9; // 声明变量a、b、c、d，并赋值
System.out.println("-------位运算符案例-------");
System.out.println("5&8=" + (a & b)); // 按位与运算
System.out.println("5|9=" + (a | c)); // 按位或运算
System.out.println("~9=" + (~c)); // 按位取反运算
System.out.println("5^9=" + (a ^ c)); // 按位异或运算
System.out.println("9<<3=" + (c << 3)); // 左移运算
System.out.println("b>>2=" + (b >> 2)); // 正数右移运算
System.out.println("-9>>3=" + (d >> 2)); // 负数右移运算
System.out.println("-9>>>3=" + (d >>> 3)); // 负数无符号右移运算
}
}
程序的运行结果如下：
标准输出：-------位运算符案例-------
5&8=0
5|9=13
~9=-10
5^9=12
9<<3=72
b>>2=2
-9>>3=-3
-9>>>3=536870910
程序中，第 5~8 行代码对上面的“&、|、~、^”位运算符运算做了验证。通过案例可以发现，数值每次左移一位，其值会变成原来的 2 倍。
第 9 行代码中，c 值为 9，向左移动 3 位时，结果变为 72（9×2×2×2 = 72）；同样地，右移一个位时是除以 2，第 10 行代码中 b 值为 8，向右移动 2 位时，移位结果为 2（8/2/2 = 2）。
第 11 行代码和第 12 行代码的区别是，“>>”是负数的右移运算，高位补 1，而“>>>”是无符号右移运算，高位补 0。
Java条件运算符
条件运算符也称三元运算符，由符号“?”和“:”组合构成，需要 3 个操作数，其语法格式如下：
(逻辑表达式) ? 结果表达式1 : 结果表达式2;
条件运算符的运算规则是：先对布尔类型的表达式求值，如果结果为 true，就执行冒号“:”前面的结果表达式 1，否者就执行后面的结果表达式 2。
接下来，通过案例来演示条件运算符的使用：
public class Demo {
public static void main(String[] args) {
int a = 5, b = 4, max; // 声明变量a、b和max
max = a > b ? a : b; // max求a、b中的最大值
System.out.println("最大值max=" + max);
}
}
程序的运行结果如下：
max=5
程序中，因为 a 的值为 5，b 的值为 4，表达式“a > b”结果为 true，则执行“?”后的语句，即将 a 的值赋给变量 max，最终 max 的值为 5。
如果要通过测试某个表达式的值来选择两个表达式中的一个进行计算时，使用条件运算符无疑是一种简练的方法。
Java运算符的优先级
在表达式运算中，用括号指明每一步的操作是非常麻烦的，因此程序设计语言引入了运算符的优先级来简化编程工作。
运算符的优先级与日常数学运算规则基本类似，如先乘除后加减等。对于一个表达式进行运算时，要按照运算符的优先顺序从高到低进行，同级别的运算符则按从左到右的方向进行。
运算符的优先级如下表所示：
表：运算符的优先级
优先级
运算符
运算符说明
结合性
1
()
分隔符
从左向右
2
! +（正） -（负） ~ ++ --
一元运算符
从右向左
3
* / %
算术运算符
从左向右
4
+（加） -（减）
算术运算符
从左向右
5
<< >> >>>
移位运算符
从左向右
6
< <= >= > instanceof
关系运算符
从左向右
7
== !=
关系运算符
从左向右
8
&
位逻辑运算符
从左向右
9
^
位逻辑运算符
从左向右
10
|
位逻辑运算符
从左向右
11
&&
逻辑运算符
从左向右
12
||
逻辑运算符
从左向右
13
?:
条件运算符
从右向左
14
= += *= /= %= &= ^= <<= >>= >>>=
赋值运算符
从右向左