Java程序设计基础——–运算符
1.算数运算符
运算符丰富是 Java 语言的主要特点之一，它提供的运算符数量之多，在高级语言中是少见的。
Java 语言中的运算符除了具有优先级之外，还有一个结合性的特点。当一个表达式中出现多种运算符时，执行的先后顺序不仅要遵守运算符优先级别的规定，还要受运算符结合性的约束，以便确定是自左向右进行运算还是自右向左进行运算。这些运算符按照操作数的数量可以分为单目运算符、双目运算符和三目运算符。
最基本的运算符包括算术运算符、赋值运算符、逻辑运算符和关系运算符等，本文将详细介绍算术运算符。
Java 中的算术运算符主要用来组织数值类型数据的算术运算，按照参加运算的操作数的不同可以分为一元运算符和二元运算符。
1.1一元运算符
算术一元运算一共有 3 个，分别是 -、++ 和 –。
| 运算符 | 名称 | 说明 | |
|---|---|---|---|
| – | 取反符号 | 取反运算 | b=-a |
| ++ | 自加一 | 先取值再加一，或先加一再取值 | a++ 或 ++a |
| – | 自减一 | 先取值再减一，或先减一再取值 | a– 或 –a |
-a 是对 a 取反运算，a++ 或 a– 是在表达式运算完后，再给 a 加一或减一。而 ++a 或 –a 是先给 a 加一或减一，然后再进行表达式运算。
int a = 12;
System.out.println(-a);
int b = a++;
System.out.println(b);
b = ++a;
System.out.println(b);
上述代码第 2 行是 -a，是把 a 变量取反，结果输出是 -12。第 4 行代码是先把 a 赋值给 b 变量再加一，即先赋值后 ++，因此输出结果是 12。第 6 行代码是把 a 加一，然后把 a 赋值给 b 变量，即先 ++ 后赋值，因此输出结果是 14。
输出结果：
1.2二元运算符
Java 语言中算术运算符的功能是进行算术运算，除了经常使用的加（+）、减（-）、乘（*）和除（\）外，还有取模运算（％）。加（+）、减（-）、乘（*）、除（\）和我们平常接触的数学运算具有相同的含义。
| 运算符 | 名称 | 说明 | |
|---|---|---|---|
| + | 加 | 求 a 加 b 的和，还可用于 String 类型，进行字符串连接操作 | a + b |
| – | 减 | 求 a 减 b 的差 | a – b |
| * | 乘 | 求 a 乘以 b 的积 | a * b |
| / | 除 | 求 a 除以 b 的商 | a / b |
| % | 取余 | 求 a 除以 b 的余数 | a % b |
算术运算符都是双目运算符，即连接两个操作数的运算符。优先级上，*、/、％ 具有相同运算级别，并高于 +、-（+、- 具有相同级别）。
int a = 4, b = 2, c = 3;
int d = a * (b + c) % c;
这种运算规则与数学运算中的规则是相同的。首先计算赋值符号（=）右边配对的括号内的值，其次按从左向右的结合方向计算乘法，最后做求余运算，表达式的结果为 2， 然后把 2 赋值给 d。
进行算术运算时应注意以下两点：
- 求余（％）运算要求参与运算的两个操作数均为整型，不能为其他类型。
- 两个整数进行除法运算，其结果仍为整数。如果整数与实数进行除法运算，则结果为实数。
在 ① 中整型变量 x 和 y 相除，其结果仍为整型数据 0；在 ② 中由于两个不同类型的数据进行运算，此时首先要进行类型转换，会把 int 型的 y 转换成与 x 一样的 float 型，然后相除，最终结果为 float 类型的数字 0.5。
编写一个程序，输出不同类型的两个数，执行相加、相减、相乘、相除和求余后输入结果。
public static void main(String[] args) {
float f1 = 9 % 4;// 保存取余后浮点类型的结果
double da = 9 + 4.5; // 双精度加法
double db = 9 - 3.0; // 双精度减法
double dc = 9 * 2.5; // 双精度乘法
double dd = 9 / 3.0; // 双精度除法
double de = 9 % 4; // 双精度取余
System.out.println("整数的算术运算"); // 整数的加、减、乘、除和取余
System.out.printf("9+4=%d \n", 9 + 4);
System.out.printf("9-4=%d \n", 9 - 4);
System.out.printf("9*4=%d \n", 9 * 4);
System.out.printf("9/4=%d \n", 9 / 4);
System.out.printf("9%%4=%d \n", 9 % 4);
System.out.println("\n浮点数的算术运算"); // 浮点数的加、减、乘、除和取余
System.out.printf("9+4.5f=%f \n", 9 + 4.5f);
System.out.printf("9-3.0f=%f \n", 9 - 3.0f);
System.out.printf("9*2.5f=%f \n", 9 * 2.5f);
System.out.printf("9/3.0f=%f \n", 9 / 3.0f);
System.out.printf("9%%4=%f \n", f1);
System.out.println("\n双精度数的算术运算"); // 双精度数的加、减、乘、除和取余
System.out.printf("9+4.5=%4.16f \n", da);
System.out.printf("9-3.0=%4.16f \n", db);
System.out.printf("9*2.5=%4.16f \n", dc);
System.out.printf("9/3.0=%4.16f \n", dd);
System.out.printf("9%%4=%4.16f \n", de);
System.out.println("\n字符的算术运算"); // 对字符的加法和减法
System.out.printf("'A'+32=%d \n", 'A' + 32);
System.out.printf("'A'+32=%c \n", 'A' + 32);
System.out.printf("'a'-'B'=%d \n", 'a' - 'B');
}
保存文件并运行，输出的结果如下所示。
整数的算术运算
9+4=13
9-4=5
9*4=36
9/4=2
9%4=1
浮点数的算术运算
9+4.5f=13.500000
9-3.0f=6.000000
9*2.5f=22.500000
9/3.0f=3.000000
9%4=1.000000
双精度数的算术运算
9+4.5=13.5000000000000000
9-3.0=6.0000000000000000
9*2.5=22.5000000000000000
9/3.0=3.0000000000000000
9%4=1.0000000000000000
字符的算术运算
'A'+32=97
'A'+32=a
'a'-'B'=31
本示例中使用了 4 种类型来执行算术运算。其中，整数类型的结果最容易理解，浮点型和双精度型返回的结果都带有小数，字符型将会把字符转换为 ASCII 码再运算。
从输出结果中可以看到，整数之间的运算结果只保留整数部分，浮点型运算时保留 6 位小数部分，双精度运算时则保留 16 位小数部分。
注意：Java 语言算术运算符的优先级是先乘除后加减。例如在表达式“a-bc”中，b 的左侧为减号，右侧为乘号，而乘号优先级高于减号，因此该表达式可以转换为“a-(bc)”。
如果在一个表达式中的多个算术运算符的优先级别相同，例如“a-b+c”，此时将按照运算符的结合方向决定顺序。算术运算符的结合方向都是“从左至右”，即先左后右。因此 b 先与减号结合，执行“a-b”的运算，再执行加 c 的运算。
1.3算数赋值运算符
算术赋值运算符只是一种简写，一般用于变量自身的变化。
| 运算符 | 名称 | 例子 |
|---|---|---|
| += | 加赋值 | a += b、a += b+3 |
| -= | 减赋值 | a -= b |
| *= | 乘赋值 | a *= b |
| /= | 除赋值 | a /= b |
| %= | 取余赋值 | a %= b |
示例：
int a = 1;
int b = 2;
a += b; // 相当于 a = a + b
System.out.println(a);
a += b + 3; // 相当于 a = a + b + 3
System.out.println(a);
a -= b; // 相当于 a = a - b
System.out.println(a);
a *= b; // 相当于 a=a*b
System.out.println(a);
a /= b; // 相当于 a=a/b
System.out.println(a);
a %= b; // 相当于 a=a%b
System.out.println(a);
运行结果：
2.赋值运算符
其语法格式如下所示：
变量名称=表达式内容
在 Java 语言中，“变量名称”和“表达式”内容的类型必须匹配，如果类型不匹配则需要自动转化为对应的类型。
赋值运算符的优先级低于算术运算符，结合方向是自右向左；不是数学中的等号，它表示一个动作，即将其右侧的值送到左侧的变量中（左侧只允许是变量，不能是表达式或其他形式）；不要将赋值运算符与相等运算符“==”混淆。
赋值运算符与其他运算符一起使用，可以表达多种赋值运算的变异效果。例如，在基本的赋值运算符的基础之上，可以结合算术运算符，以及后面要学习的位运算符，组合成复合的赋值运算符。
| 运算符 | 含义 | 实例 | |
|---|---|---|---|
| += | 将该运算符左边的数值加上右边的数值， 其结果赋值给左边变量本身 | int a=5; a+=2; | a=7 |
| -= | 将该运算符左边的数值减去右边的数值， 其结果赋值给左边变量本身 | int a=5; a-=2; | a=3 |
| *= | 将该运算符左边的数值乘以右边的数值， 其结果赋值给左边变量本身 | int a=5; a*=2; | a=10 |
| /= | 将该运算符左边的数值整除右边的数值， 其结果赋值给左边变量本身 | int a=5; a/=2; | a=2 |
| %= | 将该运算符左边的数值除以右边的数值后取余，其结果赋值给左边变量本身 | int a=5; a%=2; | a=1 |
在大型程序中，灵活运用这些赋值运算符可以提高程序的易读性，并且使程序更加容易保护。
int x, y, z; // 定义3个整型的变量
x = y = z = 5; // 为变量赋初值为5
x += 10; // 等价于x=x+10，结果x=15
y -= 3; // 等价于y=y-3，结果y=2
z *= 5; // 等价于z=z*5，结果z=25
x /= 4; // 等价于x=x/4，结果x=3
z %= x; // 等价于z=z%x，结果z=1
商城购物小案例：
一件商品的单价从 10.25 元降了 1.25 元，而自己购买的数量由原来的两个增加到 10 个，可以使用复合赋值运算符来计算购买商品的总价。
public static void main(String[] args) {
double price = 10.25; // 定义商品的单价，赋值为10.25
double total = 0; // 定义总价初始为0
int count = 2; // 定义购买数量，赋值为2
price -= 1.25; // 减去降价得到当前单价
count *= 5; // 现在需要购买10个，即原来数量的5倍
total = price * count; // 总价=当前单价*数量
System.out.printf("商品当前的单价为：%4.2f \n", price); // 输出当前单价
System.out.printf("购买商品的数量为：%d \n", count); // 输出购买数量
System.out.printf("总价为：%4.2f \n", total); // 输出总价
}
执行结果：
注意：虽然 Java 支持这种一次为多个变量赋值的写法，但这种写导致程序的可读性降低，因此不推荐这样写。
在该程序中，表示商品单价的 price 变量值为 10.25，而现在降了 1.25，在原来的基础上减去 1.25 即可获取现在的单价。而原来购买的数量为两个，现在需要购买 10 个，可以使用“count*=5”将数量乘以 5 倍之后的值赋值给 count 本身。
赋值运算符还用于将表达式的值赋给变量，如下代码是正确的。
double d1 = 12.34
double d2 = d1 + 5; // 将表达式的值赋给d2
System.out.println(d2); // 输出 d2 的值，将输出 17.34
赋值运算符还可与其他运算符结合，扩展成功能更加强大的赋值运算符。
3.逻辑运算符
逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。
逻辑运算符是对布尔型变量进行运算，其结果也是布尔型 。
| 运算符 | 用法 | 含义 | 说明 | 实例 | 结果 |
|---|---|---|---|---|---|
| && | a&&b | 短路与 | ab 全为 true 时，计算结果为 true，否则为 false。 | 2>1&&3<4 | true |
| || | a||b | 短路或 | ab 全为 false 时，计算结果为 false，否则为 true。 | 2<1||3>4 | flase |
| ！ | !a | 逻辑非 | a 为 true 时，值为 false，a 为 false 时，值为 true | !(2>4) | true |
| | | a|b | 逻辑或 | ab 全为 false 时，计算结果为 false，否则为 true | 1>2|3>5 | flase |
| & | a&b | 逻辑与 | ab 全为 false 时，计算结果为 false，否则为 true | 1<2&3<5 | true |
- && 与 & 区别：如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false）
- || 与 | 区别：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）
注意：短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。
结果为 boolean 型的变量或表达式可以通过逻辑运算符结合成为逻辑表达式。
| a | b | a&&b | a||b | !a |
|---|---|---|---|---|
| true | true | true | true | flase |
| flase | true | flase | true | true |
| true | flase | flase | true | flase |
| flase | flase | flase | flase | true |
逻辑运算符的优先级为：！运算级别最高，&& 运算高于 || 运算。！运算符的优先级高于算术运算符，而 && 和 || 运算则低于关系运算符。结合方向是：逻辑非（单目运算符）具有右结合性，逻辑与和逻辑或（双目运算符）具有左结合性。
下面是一些使用逻辑运算符的示例 :
x>0 && x<=100 // 第一行语句
y%4==0 || y%3==0 // 第二行语句
!(x>y) // 第三行语句
其中，第一行语句用于判断 x 的值是否大于 0 且小于或等于 100，只有两个条件同时成立结果才为真（true）。第二行语句用于判断 y 的值是否能被 4 或者 3 整除，只要有一个条件成立，结果就为真（true）。第三行语句先比较 x 和 y，再将比较结果取反，即如果 x 大于 y 成立，则结果为假（false），否则为真（true）。
4.关系运算符
关系运算符（relational operators）也可以称为“比较运算符”，用于用来比较判断两个变量或常量的大小。关系运算符是二元运算符，运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。
关系表达式是由关系运算符连接起来的表达式。关系运算符中“关系”二字的含义是指一个数据与另一个数据之间的关系，这种关系只有成立与不成立两种可能情况，可以用逻辑值来表示，逻辑上的 true 与 false 用数字 1 与 0 来表示。关系成立时表达式的结果为 true（或 1），否则表达式的结果为 false（或 0）。
| 运算符 | 含义 | 说明 | 实例 | 结果 |
|---|---|---|---|---|
| > | 大于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值大于后面变量的值， 则返回 true。 | 2>3 | flase |
| >= | 大于或等于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值大于等于后面变量的值， 则返回 true。 | 4>=2 | true |
| < | 小于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值小于后面变量的值，则返回 true。 | 2<3 | true |
| <= | 小于或等于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值小于等于后面变量的值， 则返回 true。 | 4<=2 | flase |
| == | 相等运算符 | 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值不相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 Java 也支持两个 boolean 类型的值进行比较。 |
44 97’a’ 5.05 truefalse |
true true true flase |
| != | 不相等运算符 | 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值不相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 |
4!=2 | true |
注意点如下所示：
- 基本类型的变量、值不能和引用类型的变量、值使用 == 进行比较；boolean 类型的变量、值不能与其他任意类型的变量、值使用 == 进行比较；如果两个引用类型之间没有父子继承关系，那么它们的变量也不能使用 == 进行比较。
- == 和 != 可以应用于基本数据类型和引用类型。当用于引用类型比较时，比较的是两个引用是否指向同一个对象，但当时实际开发过程多数情况下，只是比较对象的内容是否相当，不需要比较是否为同一个对象。
关系运算符的优先级为：>、<、>=、<= 具有相同的优先级，并且高于具有相同优先级的 !=、==。关系运算符的优先级高于赋值运算符而低于算术运算符，结合方向是自左向右。
关系表达式通常用于 Java 程序的逻辑判断语句的条件表达式中。使用关系表达式要注意以下几点：
- 运算符 >=、==、！=、<= 是两个字符构成的一个运算符，用空格从中分开写就会产生语法错误。例如
x> =y;是错误的，但是可以写成x >= y;在运算符的两侧增加空格会提高可读性。同样将运算符写反，例如 =>、=<、=! 等形式会产生语法错误。 - 由于计算机内存放的实数与实际的实数存在着一定的误差，如果对浮点数进行 ==（相等）或 !=（不相等）的比较，容易产生错误结果，应该尽量避免。
- 不要将“==”写成“=”。
下面是一些使用关系运算符的示例。
a > b // 比较变量a的值是否大于变量b的值
x+y> = z // 比较变量x与变量y的和是否大于或等于变量z的值
width * width+size != area // 比较变量width的平方加上变量size的值是否与变量area的值不相等
name == "zhht" // 比较变量name的值是否等于字符串nzht
pass != "123456" // 比较变量pass的值是否不等于字符串“123456”
案例：
要求输入两个数，并判断两个数的大小：
import java.util.Scanner;
public static void main(String[] args) {
int number1, number2; // 定义变量，保存输入的两个数
System.out.print("请输入第一个整数(number1)：");
Scanner input = new Scanner(System.in);
number1 = input.nextInt(); // 输入第一个数
System.out.print("请输入第二个整数(number2)：");
input = new Scanner(System.in);
number2 = input.nextInt(); // 输入第二个数
System.out.printf("number1=%d,number2=%d\n", number1, number2); // 输出这两个数
// 判断用户输入的两个数是否相等
if (number1 == number2) {
System.out.println("number1 和 number2 相等。");
}
// 判断用户输入的两个数据是否相等
if (number1 != number2) {
System.out.println("number1 和 number2 不相等。");
// 判断用户输入的数1是否大于数2
if (number1 > number2) {
System.out.println("number1 大于 number2。");
}
// 判断用户输入的数1是否小于数2
if (number1 < number2) {
System.out.println("number1 小于 number2。");
}
}
}
程序运行结果：
在本程序中，使用 input.nextInt() 接收用户从键盘输入的两个数，然后通过关系运算符来比较这两个数之间的大小。
5.自增自减运算符
在对一个变量做加 1 或减 1 处理时，可以使用自增运算符 ++ 或自减运算 –。++ 或 – 是单目运算符，放在操作数的前面或后面都是允许的。++ 与 – 的作用是使变量的值增 1 或减 1。操作数必须是一个整型或浮点型变量。自增、自减运算的含义及其使用实例 。
| 运算符 | 含义 | 实例 | |
|---|---|---|---|
| i++ | 将 i 的值先使用再加 1 赋值给 i 变量本身 | int i=1; int j=i++; |
i=2 j=1 |
| ++i | 将 i 的值先加 1 赋值给变量 i 本身后再使用 | int i=1; int j=++i; |
i=2 j=2 |
| i– | 将 i 的值先使用再减 1 赋值给变量 i 本身 | int i=1; int j=i–; |
i=0 j=1 |
| –i | 将 i 的值先减 1 后赋值给变量 i 本身再使用 | int i=1; int j=–i; |
i=0 j=0 |
在使用自增/自减运算时应注意下面几个问题。
- 自增/自减只能作用于变量，不允许对常量、表达式或其他类型的变量进行操作。常见的错误是试图将自增或自减运算符用于非简单变量表达式中。
- 自增/自减运算可以用于整数类型 byte、short、int、long，浮点类型 float、double，以及字符串类型 char。
- 在 Java 1.5 以上版本中，自增/自减运算可以用于基本类型对应的包装器类 Byte、Short、Integer、Long、Float、Double 和 Character。
- 自增/自减运算结果的类型与被运算的变量类型相同。
编写一个程序，使用不同类型的数据结合自增和自减运算符进行运算，并输出变量的值。
public static void main(String[] args) {
int x = 5, y; // 声明用于自增和自减的整型变量
char cx = 'B', cy; // 声明用于自增和自减的字符型变量
float fx = 5.5f, fy; // 声明用于自增和自减的浮点型变量
System.out.println("---------对整数的自增和自减---------");
y = x++;
System.out.printf("y=x++ 的结果为：%d ,%d \n", x, y);
y = x--;
System.out.printf("y=x-- 的结果为：%d ,%d \n", x, y);
y = ++x;
System.out.printf("y=++x 的结果为：%d ,%d \n", x, y);
y = --x;
System.out.printf("y=--x 的结果为：%d ,%d \n", x, y);
System.out.println("\n---------对浮点的自增和自减---------");
fy = fx++;
System.out.printf("fy=fx++ 的结果为：%f ,%f \n", fx, fy);
fy = fx--;
System.out.printf("fy=fx-- 的结果为：%f ,%f \n", fx, fy);
fy = ++fx;
System.out.printf("fy=++fx 的结果为：%f ,%f \n", fx, fy);
fy = --fx;
System.out.printf("fy=--fx 的结果为：%f ,%f \n", fx, fy);
System.out.println("\n---------对字符的自增和自减---------");
cy = cx++;
System.out.printf("cy=cx++ 的结果为：%c ,%c \n", cx, cy);
cy = cx--;
System.out.printf("cy=cx-- 的结果为：%c ,%c \n", cx, cy);
cy = ++cx;
System.out.printf("cy=++cx 的结果为：%c ,%c \n", cx, cy);
cy = --cx;
System.out.printf("cy=--cx 的结果为：%c ,%c \n", cx, cy);
}
保存代码并运行，输出的结果如下：
---------对整数的自增和自减---------
y=x++ 的结果为：6 ,5
y=x-- 的结果为：5 ,6
y=++x 的结果为：6 ,6
y=--x 的结果为：5 ,5
---------对浮点的自增和自减---------
fy=fx++ 的结果为：6.500000 ,5.500000
fy=fx-- 的结果为：5.500000 ,6.500000
fy=++fx 的结果为：6.500000 ,6.500000
fy=--fx 的结果为：5.500000 ,5.500000
---------对字符的自增和自减---------
cy=cx++ 的结果为：C ,B
cy=cx-- 的结果为：B ,C
cy=++cx 的结果为：C ,C
cy=--cx 的结果为：B ,B
从运行结果来看，无论是何种类型，只要是自增和自减运算符支持的类型，都可以参与运算。
6.位运算符
Java 定义的位运算（bitwise operators）直接对整数类型的位进行操作，这些整数类型包括 long，int，short，char 和 byte。
位运算符主要用来对操作数二进制的位进行运算。按位运算表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值。
Java 语言中的位运算符分为位逻辑运算符和位移运算符两类，下面详细介绍每类包含的运算符。
6.1位逻辑运算符
位逻辑运算符包含 4 个：&（与）、|（或）、~（非）和 ^（异或）。除了 ~（即位取反）为单目运算符外，其余都为双目运算符。表 1 中列出了它们的基本用法。
| 运算符 | 含义 | 实例 | 结果 |
|---|---|---|---|
| & | 按位进行与运算（AND） | 4 & 5 | 4 |
| | | 按位进行或运算（OR） | 4|5 | 5 |
| ^ | 按位进行异或运算（XOR） | 4 ^ 5 | 1 |
| ~ | 按位进行取反运算（NOT） | ~ 4 | -5 |
6.2位与运算符
位与运算符为&，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时为 1，那么计算结果才为 1，否则为 0。因此，任何数与 0 进行按位与运算，其结果都为 0。
例如下面的表达式：
100&0
所示为这个运算过程，结果为 0。
下面是两个非零的数字进行位与运算的过程。
int x = 5,y = 12; // 创建整型变量保存两个数
int z = x&y; // 对这两个数进行位与运算，结果保存到z
这两行语句执行后变量 Z 的值是 4 。
6.3位或运算符
位或运算符为| 其运算规则是：参与运算的数字，低位对齐，高位不足的补零。如果对应的二进制位只要有一个为 1，那么结果就为 1；如果对应的二进制位都为 0，结果才为 0。
下面是一个使用位或运算符的表达式。
11|7
运算结果为 15 。
6.4位异或运算符
位异或运算符为^，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位相同（同时为 0 或同时为 1）时，结果为 0；如果对应的二进制位不相同，结果则为 1。
下面是一个使用位异或运算符的表达式。
11^7
提示：在有的高级语言中，将运算符^作为求幂运算符，要注意区分。
6.5位取反运算符
位取反运算符为~，其运算规则是：只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1。
下面是一个使用位取反运算符的表达式。
~10
运算结果为 65525 。
我们可以使用如下的程序来检查这个运算结果。
int i = 10;
System.out.printf("%d \n",~i);
编译执行以上程序，会发现输出的结果是 -11，而不是 65525。这是因为取反之后的结果是十六进制数，而在上面的程序中使用 %d 将输出转换为了十进制数。
可以使用如下语句查看十六进制结果。
int i=10;
System.out.printf("%x \n",~i);
可以看到输出结果为 fff5，将它转换为二进制是 1111111111110101。这个二进制数的最高位为 1，表示这个数为负数。除最高位外，按位取反再加 1，即得到二进制原码 1000000000001011，用十进制数表示即为 -11。
注意：位运算符的操作数只能是整型或者字符型数据以及它们的变体，不用于 float、double 或者 long 等复杂的数据类型。
6.6位移运算符
位移运算符用来将操作数向某个方向（向左或者右）移动指定的二进制位数。 Java 语言中的两个位移运算符，它们都属于双目运算符。
| 运算符 | 含义 | 实例 | 结果 |
|---|---|---|---|
| >> | 右移位运算符 | 8>>1 | 4 |
| << | 左移位运算符 | 9<<2 | 36 |
左位移运算符
左移位运算符为«，其运算规则是：按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。
将整数 11 向左位移 1 位的过程
原来数的所有二进制位都向左移动 1 位。原来位于左边的最高位 0 被移出舍弃，再向尾部追加 0 补位。最终到的结果是 22，相当于原来数的 2 倍。
右位移运算符
右位移运算符为»，其运算规则是：按二进制形式把所有的数字向右移动对应的位数，低位移出（舍弃），高位的空位补零。
将整数 11 向右位移 1 位的过程
原来位于右边的最低位 1 被移出舍弃，再向最高位追加 0 补位。最终到的结果是 5，相当于原数整除 2 的结果。
6.7复合位赋值运算
所有的二进制位运算符都有一种将赋值与位运算组合在一起的简写形式。复合位赋值运算符由赋值运算符与位逻辑运算符和位移运算符组合而成。 列出了组合后的复合位赋值运算符。
| 运算符 | 含义 | 实例 | 结果 |
|---|---|---|---|
| &= | 按位与赋值 | num1 &= num2 | 等价于 num 1=num 1 & num2 |
| |= | 按位或赋值 | num1 |= num2 | 等价于 num 1=num 1 | num2 |
| ^= | 按位异或赋值 | num1 ^= num2 | 等价于 num 1=num 1 ^ num2 |
| -= | 按位取反赋值 | num1 ~= num2 | 等价于 num 1=num 1 ~ num2 |
| <<= | 按位左移赋值 | num1 «= num2 | 等价于 num 1=num 1 « num2 |
| >>= | 按位右移赋值 | num1 »= num2 | 等价于 num 1=num 1 » num2 |
下面的程序定义了几个 int 型变量，然后运用位赋值简写的形式将运算后的值赋给相应的变量：
int a = 1;
int b = 2;
int c = 3;
a &= 4;
a |= 4;
a ^= c;
a -= 6;
b >>= 1;
c <<= 1;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
该程序的输出为：
a = 1
b = 1
c = 6
7.条件运算符
Java 提供了一个特别的三元运算符（也叫三目运算符）经常用于取代某个类型的 if-then-else 语句。条件运算符的符号表示为“?:”，使用该运算符时需要有三个操作数，因此称其为三目运算符。使用条件运算符的一般语法结构为：
result = <expression> ? <statement1> : <statement3>;
其中，expression 是一个布尔表达式。当 expression 为真时，执行 statement1， 否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符。
下面是一个使用条件运算符的示例。
int x,y,z;
x = 6,y = 2;
z = x>y ? x-y : x+y;
在这里要计算 z 的值，首先要判断 x>y 表达的值，如果为 true，z 的值为 x-y；否则 z 的值为 x+y。很明显 x>y 表达式结果为 true，所以 z 的值为 4。
技巧：可以将条件运算符理解为 if-else 语句的简化形式，在使用较为简单的表达式时，使用该运算符能够简化程序代码，使程序更加易读。
在使用条件运算符时，还应该注意优先级问题，例如下面的表达式：
x>y ? x-=y : x+=y;
在编译时会出现语法错误，因为条件运算符优先于赋值运算符，上面的语句实际等价于：
(x>y ? x-=y : x)+=y;
而运算符“+=”是赋值运算符，该运算符要求左操作数应该是一个变量，因此出现错误。为了避免这类错误，可以使用括号“0”来加以区分。例如，下面是正确的表达式。
(x>y) ? (x-=y): (x+=y);
在程序中声明 3 个变量 x、y、z，并由用户从键盘输入 x 的值，然后使用条件运算符向变量 y 和变量 z 赋值。
import java.util.Scanner;
public class Test9 {
public static void main(String[] args) {
int x, y, z; // 声明三个变量
System.out.print("请输入一个数：");
Scanner input = new Scanner(System.in);
x = input.nextInt(); // 由用户输入x的值
// 判断x的值是否大于5，如果是y=x，否则y=-x
y = x > 5 ? x : -x;
// 判断y的值是否大于x，如果是z=y，否则z=5
z = y > x ? y : 5;
System.out.printf("x=%d \n", x);
System.out.printf("y=%d \n", y);
System.out.printf("z=%d \n", z);
}
}
运行结果为：
在该程序中，首先输入 x 的值为 58，然后判断 x 的值是否大于 5，显然条件是成立，则 y 的值为 x，即 y=58。接着判断 y 的值是否大于 x，因为 y 的值和 x 的值都为 58，所以该条件是不成立的，则 z=5。再次输入 x 的值为 4，然后判断 x 的值是否大于 5，不成立，则 y=-4；接着判断 y 的值是否大于 x，不成立，则 z=5。
8.运算符优先级
所有的数学运算都认为是从左向右运算的，Java 语言中大部分运算符也是从左向右结合的，只有单目运算符、赋值运算符和三目运算符例外，其中，单目运算符、赋值运算符和三目运算符是从右向左结合的，也就是从右向左运算。
乘法和加法是两个可结合的运算，也就是说，这两个运算符左右两边的操作数可以互换位置而不会影响结果。运算符有不同的优先级，所谓优先级就是在表达式运算中的运算顺序。
一般而言，单目运算符优先级较高，赋值运算符优先级较低。算术运算符优先级较高，关系和逻辑运算符优先级较低。多数运算符具有左结合性，单目运算符、三目运算符、赋值运算符具有右结合性。
Java 语言中运算符的优先级共分为 14 级，其中 1 级最高，14 级最低。在同一个表达式中运算符优先级高的先执行。
| 优先级 | 运算符 | 结合性 |
|---|---|---|
| 1 | （）、[]、{} | 从左向右 |
| 2 | !、+、-、~、++、– | 从右向左 |
| 3 | *、/、% | 从左向右 |
| 4 | +、- | 从左向右 |
| 5 | «、»、>>> | 从左向右 |
| 6 | <、<=、>、>=、instanceof | 从左向右 |
| 7 | ==、!= | 从左向右 |
| 8 | & | 从左向右 |
| 9 | ^ | 从左向右 |
| 10 | | | 从左向右 |
| 11 | && | 从左向右 |
| 12 | || | 从左向右 |
| 13 | ?: | 从右向左 |
| 14 | =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= | 从右向左 |
使用优先级为 1 的小括号可以改变其他运算符的优先级，即如果需要将具有较低优先级的运算符先运算，则可以使用小括号将该运算符和操作符括起来。例如下面的表达式：
(x-y)*z/5
在这个表达式中先进行括号内的减法运算，再将结果与 z 相乘，最后将积除以 5 得出结果。整个表达式的顺序按照从左向右执行，比较容易理解。
再来看一个复杂的表达式，如下所示。
--y || ++x && ++z;
这个表达式中包含了算术运算符和逻辑运算符。根据表 1 中列出的优先级，可以确定它的执行顺序如下：
① 先计算 y 的自减运算符，即 –y。
② 再计算 x 的自增运算符，即 ++x。
③ 接着计算 z 的自增运算符，即 ++z。
④ 由于逻辑与比逻辑或的优先级高，这里将 ② 和 ③ 的结果进行逻辑与运算，即 ++x && ++z。
⑤ 最后将 ④ 的结果与 ① 进行逻辑或运算，即 –y||++x&&++z。
如果没有上述对该表达式执行顺序的说明，第一眼看到它时将很难识别优先级。对于这类问题，可以通过添加小括号使表达的顺序更加清晰，而不用去查优先级表。如下所示为改进后的表达式。
(--y) || ((++x)&&(++z));
技巧：记住这么多运算符的优先级是比较困难的，因此读者应该在实际应用中多多练习。
因为 Java 运算符存在这种优先级的关系，因此在做 SCJP 的时候或者某些公司的面试题，有如下 Java 代码：
int a = 5;
int b = 4;
int c = a++- --b*++a/b-- >>2%a--;
问 c 的值是多少？这样的语句实在太恐怖了，即使多年的老程序员看到这样的语句也会眩晕。这样的代码只能在考试中出现，作为一个程序员如果写这样的代码，恐怕他马上就得走人了，因为他完全不懂程序开发。
源代码就是一份文档，源代码的可读性比代码运行效率更重要。 因此在这里要提醒大家：
- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。
- 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用
()来控制表达式的执行顺序。
9.直接量
9.1直接量的类型
并不是所有的数据类型都可以指定直接量，能指定直接量的通常只有三种类型：基本类型、字符串类型和 null 类型。具体而言，Java 支持如下 8 种类型的直接量。
1）int 类型的直接量
在程序中直接给出的整型数值，可分为二进制、十进制、八进制和十六进制 4 种，其中二进制需要以 0B 或 0b 开头，八进制需要以 0 开头，十六进制需要以 0x 或 0X 开头。例如 123、012（对应十进制的 10）、0x12（对应十进制的 18）等。
2）long 类型的直接量
在整型数值后添加 l 或 L 后就变成了 long 类型的直接量。例如 3L、0x12L（对应十进制的 18L）。
3）float 类型的直接量
在一个浮点数后添加 f 或 F 就变成了 float 类型的直接量，这个浮点数可以是标准小数形式，也可以是科学计数法形式。例如 5.34F、3.14E5f 。
4）double 类型的直接量
直接给出一个标准小数形式或者科学计数法形式的浮点数就是 double 类型的直接量。例如 5.34、3.14E5。
5）boolean 类型的直接量
这个类型的直接量只有 true 和 false。
6）char 类型的直接量
char 类型的直接量有三种形式，分别是用单引号括起来的字符、转义字符和 Unicode 值表示的字符。例如‘a’，‘\n’和‘\u0061’。
7）String 类型的直接量
一个用双引号括起来的字符序列就是 String 类型的直接量。
在大多数其他语言中，包括 C/C++，字符串作为字符的数组被实现。然而，在 Java 中并非如此。在 Java 中，字符串实际上是对象类型。在教程后面你将看到，因为 Java 对字符串是作为对象实现的，因此，它有广泛的字符串处理能力，而且功能既强又好用。
8）null 类型的直接量
这个类型的直接量只有一个值，即 null。
在上面的 8 种类型的直接量中，null 类型是一种特殊类型，它只有一个值：null。而且这个直接量可以赋给任何引用类型的变量，用以表示这个引用类型变量中保存的地址为空，即还未指向任何有效对象。
9.2直接量的赋值
通常总是把一个直接量赋值给对应类型的变量 。
int a = 5;
char c = 'a';
boolean b = true;
float f = 5.12f;
double d = 4.12;
String name = "C语言中文网";
String url = "http://c.biancheng.net";
除此之外，Java 还支持数值之间的自动类型转换，因此允许把一个数值直接量直接赋给另一种类型的变量，这种赋值必须是系统所支持的自动类型转换，例如把 int 类型的直接量赋给一个 long 类型的变量。
String 类型的直接量不能赋给其他类型的变量，null 类型的直接量可以直接赋给任何引用类型的变量，包括 String 类型。boolean 类型的直接量只能赋给 boolean 类型的变量，不能赋给其他任何类型的变量。
关于字符串直接量有一点需要指出，当程序第一次使用某个字符串直接量时，Java 会使用常量池（constant pool）来缓存该字符串直接量，如果程序后面的部分需要用到该字符串直接量时，Java 会直接使用常量池（constantpool）中的字符串直接量。
提示：
- 由于 String 类是一个典型的不可变类，因此 String 对象创建出来的就不可能改变，因此无需担心共享 String 对象会导致混乱。
- 常量池（constant pool）指的是在编译期被确定，并被保存在已编译的 .class 文件中的一些数据，它包括关于类、方法、接口中的常量，也包括字符串直接量。
看如下程序：
String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "llo";
System.out.println(s0 == s1);
System.out.println(s0 == s2);
运行结果为：
true
true
除此之外，Java 还支持数值之间的自动类型转换，因此允许把一个数值直接量直接赋给另一种类型的变量，这种赋值必须是系统所支持的自动类型转换，例如把 int 类型的直接量赋给一个 long 类型的变量。
String 类型的直接量不能赋给其他类型的变量，null 类型的直接量可以直接赋给任何引用类型的变量，包括 String 类型。boolean 类型的直接量只能赋给 boolean 类型的变量，不能赋给其他任何类型的变量。
关于字符串直接量有一点需要指出，当程序第一次使用某个字符串直接量时，Java 会使用常量池（constant pool）来缓存该字符串直接量，如果程序后面的部分需要用到该字符串直接量时，Java 会直接使用常量池（constantpool）中的字符串直接量。
提示：
- 由于 String 类是一个典型的不可变类，因此 String 对象创建出来的就不可能改变，因此无需担心共享 String 对象会导致混乱。
- 常量池（constant pool）指的是在编译期被确定，并被保存在已编译的 .class 文件中的一些数据，它包括关于类、方法、接口中的常量，也包括字符串直接量。
看如下程序：
String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "llo";
System.out.println(s0 == s1);
System.out.println(s0 == s2);
运行结果为：
true
true
Java 会确保每个字符串常量只有一个，不会产生多个副本。例子中的 s0 和 s1 中的“hello”都是字符串常量，它们在编译期就被确定了，所以 s0 = s1 返回 true。而“he”和“llo”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它本身也是字符串常量，s2 同样在编译期就被解析为一个字符串常量，所以 s2 也是常量池中“hello”的引用。因此，程序输出 s0 == s1 返回 true，s1 == s2 也返回 true。