目录
一、什么是运算符？
计算机的最基本的用途之一就是执行数学运算，比如：
int a = 10;
int b = 20;
a + b;
a < b;上述 + 和 < 等就是运算符，即：对操作数进行操作时的符号，不同运算符操作的含义不同。
在Java语言中，运算符可分为以下：算术运算符(+ - * /)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等。
二、具体的运算符有哪些？
1. 算术运算符
1.1基本四则运算符：(+ - * / %)
public class test {
public static void main(String[] args) {
int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0
}
}注意：
- 都是二元运算符，使用时必须要有左右两个操作数。
- int / int 结果还是 int 类型，而且会向下取整。
public class test {
public static void main(String[] args){
int a = 3;
int b = 2;
//方式一：在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
System.out.println(a / b);
//方式二：如果要得到数学中的结果，可以用double类型来接收
double d = a / b;
System.out.println(d);
}
}- 做除法和取模时，右操作数（就是除数）不能为0。
public class test {
public static void main(String[] args){
int a = 1;
int b = 0;
System.out.println(a / b); //运行报错： / by zero，所以除数不能为0
}
}- % 不仅可以对整形取模，也可以对 double 类型（双精度）取模，但是没有意义，一般都是对整形取模的。
public class test {
public static void main(String[] args) {
System.out.println(11.5 % 2.0); // 运行结果:1.5
}
}- 两操作数类型不一致时，其向大类型的提升。
public class test {
public static void main(String[] args) {
System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double,输出：1.2
}
}2. 增量运算符 += -= *= %=
public class test {
public static void main(String[] args) {
int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a -= 1; // 相当于 a = a - 1
System.out.println(a); // 输出2
a *= 3; // 相当于 a = a * 3
System.out.println(a); // 输出6
a /= 3; // 相当于 a = a / 3
System.out.println(a); // 输出2
a %= 3; // 相当于 a = a % 2
System.out.println(a); // 输出2
}注意：只有变量才能使用该运算符，常量不能使用。
3. 自增/自减运算符 ++ --
public class test {
public static void main(String[] args) {
int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符与++含义类似,可参考++操作符
}
}注意：
- 如果单独使用，【前置++】和【后置++】没有任何区别
public class test {
public static void main(String[] args) {
int a=10;
a++;
System.out.println(a); \\结果：11
++a;
System.out.println(a); \\结果：12
}
}- 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1
- 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改
2.关系运算符
关系运算符主要有六个: == != < > <= >=，其计算结果是 true 或者 false 。
public class test {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false
}注意：当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的
public class test {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
System.out.println(a < b < c); \\计算机运行过程：先计算a<b得到true，再用true与c进行比较大小，计算机会检测出类型不匹配，无法计算。
}
}运行结果：系统报错（计算出来的true是boolean类型与int类型的c无法比较大小）
3. 逻辑运算符
逻辑运算符主要有三个: &&(逻辑与) || （逻辑或） ! (逻辑非)，运算结果都是 boolean类型。
3.1逻辑与 &&（二元运算符）
语法规则：表达式1 && 表达式2(全真则真，一假则假)，表达式1、2都必须是boolean类型的结果。
public class test {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
}
}3.2逻辑 ||（二元运算符）
语法规则：表达式1 || 表达式2（一真则真，全假则假），表达式1、2都必须是boolean类型的结果。
public class test {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为假
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假
}
}3.3逻辑非 !（一元运算符）
语法规则：! 表达式（非真变假，非假变真）
public class test {
public static void main(String[] args) {
int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true
}
}4.短路求值
&& 和 || 遵守短路求值的规则.
（简单来说就是&&表达式两边只要第一个是false，就不用求了，计算结果必然是false，同理可得对于||来说只要第一个表达式为真，计算结果必然为真。）
public class test {
public static void main(String[] args) {
int a = 10;
// && 和 || 支持短路预算
//第一个表示为false，则第二个表示不参与运算，结果为false
System.out.println(a !=10 && 20 % 2 == 0);
//第一个表示为true，则第二个表示不参与运算，结果为true
System.out.println(a == 10 || 20 % 2 == 0);
}
}在java语言中也支持&（逻辑与）与 | （逻辑或）（一般不用这个）原因如下：
- & | 不支持短路求值
- & | 经常用来进行按位操作：& （按位与） | （按位或）
5.位运算符
在java中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二进制比特位组成的，多个字节组合在一起可以表示各种不同的数据。
位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
位操作表示按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位 的每一位依次进行计算.
5.1按位与 &
在二进制运算中，如果两个比特位都是 1, 那么与的则结果为 1, 否则结果为 0.（简单来说就是1“与”1的结果就是1，反之则为0），如下：
5.2按位或 |
在二进制运算中，如果两个二比特位只要又一个是 1, 则结果为 1, 否则结果为 0.（简单来说就是0“或”0的结果就是0，反之则为1），如下：
注意:当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表 示逻辑运算.
5.3按位取反 ~
如果该比特位为 0 则转为 1, 如果该比特位为 1 则转为 0。（简单来说就是0变1，1变0），如下：
public class test {
public static void main(String[] args){
int a = 10;
System.out.println(~a); //运行结果：-11
//或者
// 0xA--->0000 0000 0000 0000 0000 0000 0000 1010
int b = 0xA; // ~
System.out.printf("%x",~b); //运算结果：1111 1111 1111 1111 1111 1111 1111 0101
}
}分析如下：
注意：
- 整数在内存中是以补码的形式存在的
- 原码：数据的二进制格式 ；反码：将原码取反，符号位不变 ；补码：反码+1
- 正数---->原码、反码、补码都是相同的 ；负数----->这三个是不一样的
- 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个二进制位.
- printf 能够格式化输出内容, %x 表示按照十六进制输出.
5.4按位异或 ^
二进制运算中，如果两个数字的比特位相同地方按位异或^, 则结果为 0, 相异按位异或^则结果为 1.
public class test {
public static void main(String[] args) {
int a = 0x55555555; // 0101 0101 0101 0101 0101 0101 0101 0101
int b = 0xAAAAAAAA; // ^1010 1010 1010 1010 1010 1010 1010 1010
// --------------------------------------------
System.out.println(a^b); // 1111 1111 1111 1111 1111 1111 1111 1111 -->补码
//其反码 1111 1111 1111 1111 1111 1111 1111 1110
//其原码 1000 0000 0000 0000 0000 0000 0000 0001
//在原码中第一个数字表示符号位1表示负数，其大小为1*2^(0)=1
//所以其运行结果：-1
}
}简单举例来说，如下：
6.移位运算
移位运算符有三个: > >>> ，都是二元运算符，且都是按照二进制比特位来运算的。
6.1左移 <<
最左侧位不要了, 最右侧补 0.（与符号位有关，正数可能变成负数，负数也可能变成正数）
public class test {
public static void main(String[] args) {
int a = 10; // 0000 0000 0000 0000 0000 0000 0000 1010
System.out.println(a << 1);//结果：20 0000 0000 0000 0000 0000 0000 0001 0100
System.out.println(a << 2);//结果：40 0000 0000 0000 0000 0000 0000 0010 1000
}
}得出结论：给a<<n位，就是给a乘于a^n
6.2右移 >>
最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
public class test {
public static void main(String[] args) {
int a = 10; // 0000 0000 0000 0000 0000 0000 0000 1010
System.out.println(a >> 1);//结果：5 0000 0000 0000 0000 0000 0000 0000 0101
System.out.println(a >> 2);//结果：2 0000 0000 0000 0000 0000 0000 0000 0010
}
}得出结论：给a>>n位，就是给a除于a^n
6.3无符号右移 >>>
最右侧位不要了, 最左侧补 0.
public class test {
public static void main(String[] args) {
int a = -10; // 1000 0000 0000 0000 0000 0000 0000 1010
System.out.println(a >>> 1);//结果：5 0000 0000 0000 0000 0000 0000 0000 0101
}
}注意：
- 移动负数位或者移位位数过大都没有意义.
- 没有 <<< (无符号左移)
7.条件运算符
条件运算符只有一个:
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
（简单来说：表达式1真，输出表达式2；表达式1假，输出表达式3）
public class test1 {
public static void main(String[] args) {
int a = 10;
int b = 20;
int Max = a > b ? a : b; //输出：20
System.out.println(Max);
}
}
注意：
- 三步表达式不能单独使用，其返回值必须被接收，否则编译失败。
- 第一个表达式一定要是boolean类型的，否则编译失败。
- 第二个表达式和第三个表达式的类型一定要相同，如果不同，左侧没办法接收返回值，会导致编译失败
三、运算符的优先级
例如：求两个整数的平均值（不考虑小数的情况）
public class test1 {
public static void main(String[] args) {
int a = 10;
int b = 30;
//方式一：先求和在进行除法运算，
//缺点：1.容易造成值的溢出
// 2.速度慢
int avg = (a + b) / 2;
System.out.println(avg); //输出结果：20
//方式二：优化上述问题
avg = a + (b - a) >> 1;
System.out.println(avg); //输出结果：15
//分析：先计算了b-a的差值然后在进行移位运算，经过运算分析得出：
//+号的运算级高于>>移位运算级，导致结果计算不正确
//改正：给移位运算级加上（）括号
avg = a + ((b - a) >> 1);
System.out.println(avg); //输出结果：20
}
}注意：
运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号（）即可.
674
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
