多城市网站建设企业网站页面设计
目录
什么是运算符
算术运算符
1.基本四则运算符
2.增量运算符
3.自增/自减运算符
关系运算符
逻辑运算符
&&：逻辑与
||：逻辑或
！：逻辑非
短路求值
位运算符
按位与&：
按位或 |
按位取反~
按位异或^
移位运算
左移<<
右移>>
无符号右移>>>
条件运算符
运算符的优先级
什么是运算符
int a = 10;
int b = 50;
a-b;
a+b;
a<b;上述的+和<等都是运算符.
概念：对操作数进行操作时的符号。
不同运算符操作的含义不同。
java中的运算符可分为：算术运算符、关系运算符、逻辑运算符、位运算符、移位运算符以及条件运算符等。
算术运算符
1.基本四则运算符
基本四则运算符有加减乘除模，五种，分别对应（+、-、*、/、%）
int a = 50;
int b = 10;
System.out.println(a + b); // 60
System.out.println(a - b); // 40
System.out.println(a * b); // 500
System.out.println(a / b); // 5
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数ps:
- 基本四则运算符都是二元运算符，使用时必须要有左右两个操作数。
- int/int结果还是int类型，并且结果会向下取整。
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
int a = 1;
int b = 0;
System.out.println(a / b)
// 运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.main(Test.java:5)- %不仅可以对整形取模，也可以对double类型取模，但对double类型取模并没有什么意义
System.out.println(11.5 % 2.0);
// 运行结果
1.5- 两侧操作数的类型不一致时，会向类型大的进行提升
System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
// 故：输出1.2
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 / 32.增量运算符
增量运算符包括：+=、-=、*=、%=四种。
增量运算符操作完成后，会将操纵的结果赋值给左边的操作数。
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); // 输出2ps：
只有变量才能使用该运算符，常量不可以
3.自增/自减运算符
++是给变量的值加1，--是给变量的值减1。
- 前置++和后置++如果是单独使用，那么没有任何区别。
- 如果混合使用，前置++会先加1，然后使用变量+1之后的值，而后置++会先使用变量原本的值，再进行+1操作。
- 与增量运算符一样，只有变量才能使用自增/自减运算法，常量不能使用，这是因为常量不能被修改。
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
// --操作符给操作-1，与++含义类似关系运算符
关系运算符主要有：==、!= 、< 、>、<= 、>=。
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关系运算符的计算结果往往是true或者false。
ps：
当需要多次判断，如计算a大于4但是小于7时，不能连着写，也就是不能写成4<a<7。
逻辑运算符
逻辑运算符主要有三个，分别为：&& 、||、！。
逻辑运算符的计算结果都是boolean类型，也就是说，其结果不是true就是false。
&&：逻辑与
其语法规则为：表达式1&&表达式2。
同时，左右两个表达式必须是boolean类型的结果才行。
逻辑与，相当于我们常用的“且”字。
只有当左右两个表达式都为真时，结果才是真的。
只要有一个表达式为假，结果就为假。
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); // 左为假 且 右为假 则结果为假
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); // 左为假 且 右为假 则结果为假||：逻辑或
其语法规则与逻辑与一样，都是：表达式1||表达式2，同时，其左右表达式也必须为boolean类型的结果。
逻辑或相当于我们常用的“或”字。
只要有一个表达式为真，那么结果就为真。
只有当两个表达式都为假时，结果才为假。
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); // 左为假 且 右为假 则结果为假！：逻辑非
语法规则：！表达式
逻辑非的结果是：真变假，假变真。
也就是说，当我们的表达式为真时，！表达式的结果为假。
当我们的表达式为假时，！表达式的结果为真。
int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true短路求值
&&与||都要遵守短路求值的规则。
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true根据我们之前学习的知识，当计算10/0时，程序会抛出异常，但上面这两个代码却能正常运行，这说明10/0这里并没有被真正求值。
对于&&，如果左侧表达式值为false，则表达式结果一定是false，无需计算右侧表达式。
对于||，如果左侧表达式值为true，则表达式结果一定是true，无需计算右侧表达式。
而当&和|的表达式结果为boolean时，也表示逻辑运算，但它们并不支持短路求值。
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常位运算符
我们知道，在Java中数据存储的最小单位是字节，而数据操作的最小单位是比特位。
而每个字节是由8个二进制比特位组成的，多个字节组合在一起，可以表示各种不同的数据。
位运算符主要有四个，分别为：&、|、~、^。
其中，除了~是一元运算符外，其余的都是二元运算符。
而位操作符表示按二进制位运算。
按位与&：
如果两个二进制位都是1，则结果为1，否则结果为0
int a = 10;
int b = 20;
System.out.println(a & b);
按位或 |
如果两个二进制位都是0，则结果为0，否则结果为1
int a = 10;
int b = 20;
System.out.println(a | b);
ps：
当&与|的操作数为整数（int，short，long，byte）的时候，表示按位运算。
当操作数为boolean的时候，表示逻辑运算。
按位取反~
如果该位为0则转为1，如果该位为1则转为0
int a = 0xf;
System.out.printf("%x\n", ~a)- 0x前缀的数字为十六进制数字，而十六进制可以看成是二进制的简化表示方式。
- 一个十六进制数字对应4个二进制位。
- 0xf表示10进制的15，也就是二进制的1111。
- printf能够格式化输出内容，%x则表示按照十六进制输出。
- \n表示换行符。
按位异或^
如果两个数字的二进制位相同，则结果为0，相异则结果为1.
如果两个数相同，则异或的结果为0.
int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);移位运算
移位运算符有三个，分别为<<、>>、>>>，三个运算符都是二元运算符，且都是按照二进制比特位来进行运算的。
左移<<
最左侧位不要，最右侧补0
ps：
向左移动，丢弃的是符号位，因此正数左移可能会变成负数。
int a = 0x10;
System.out.printf("%x\n", a << 1);
// 运行结果(注意, 是按十六进制打印的)
20右移>>
最右侧位不要了，最左侧补符号位（整数补0，负数补1）
int a = 0x10;
System.out.printf("%x\n", a >> 1);
// 运行结果(注意, 是按十六进制打印的)
8
int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
// 运行结果(注意, 是按十六进制打印的)
ffff8000无符号右移>>>
最右侧位不要，最左侧补0
int a = 0xffffffff;
System.out.printf("%x\n", a >>> 1);
// 运行结果(注意, 是按十六进制打印的)
7fffffff注意:
- 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
- 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
- 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
- 移动负数位或者移位位数过大都没有意义.
条件运算符
条件运算符的表达式为：
表达式1？表达式2：表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;ps：
- 表达式2与表达式3的结果必须是同类型的，除非它们能发生隐式类型转换。
int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;- 表达式不能单独存在，其产生的结果必须要被使用。
int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句运算符的优先级
在一条表达式中，各个运算符可以混合起来进行运算，但运算符的优先级不同。
// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);在上述代码中，由于+的优先级要高于>>，因此a要先与（b-a）的结果做加法，结果为20.
最后再进行右移，因此结果应为10.
注意：
运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可
// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + ((b - a) >> 1);
System.out.println(c);