在Java中提供了丰富的运算符
- 其按照功能分：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符
- 按照操作数个数分：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
我们又称用运算符连接起来的式子就是表达式。下面我们来具体学习一下每个运算符的作用吧。
算数运算符
代码示例
/*
被除数 ÷ 除数 = 商 ...... 余数
*/
public class Demo01Operator {
public static void main(String[] args) {
int a = 10;
int b = 4;
// + - * 和我们小学的规则一样
System.out.println(a + b); //14
System.out.println(a - b);//6
System.out.println(a * b);//40
//2个整数相除，结果就是商，整数相除 不保留小数，如果想要显示小数 使用浮点类型计算
System.out.println(a / b);//2
//int * double / int ==> double / int ==> double / double ==> double
System.out.println((a * 1.0) / b);// 2.5
/*
%运算符: 取余数(模)运算符
作用:
1.判断数字的奇偶性:
数字%2 结果是0 说明数字是偶数
数字%2 结果不是0 说明数字是奇数
2.判断一个数字是否能够被另外一个数字整除
结果为0: 说明可以整除
结果不为0: 说明不可以整除
*/
//结果是0 说明10是偶数，结果是 1 说明11是奇数
System.out.println(10 % 2);//0
System.out.println(11 % 2);//1
//结果是0 说明100可以被25整除，否则说明100不可以被26整除
System.out.println(100 % 25);//0
System.out.println(100 % 26);//22
}
}注意事项:
- Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。因为最高类型是整数
- 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
- / 和%的区别：两个整数做除法，/取结果的商，%取结果的余数。取模的结果只和被除数的正负号相同。
- 除数不能为0，如果除数为0，程序运行时会抛出数学异常
案例：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
import java.util.Scanner;
public class Demo04Operator {
public static void main(String[] args) {
// 1：使用Scanner键盘录入一个三位数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int num = sc.nextInt();
// 2：个位的计算：数值 % 10
int ge = num % 10; // 123 % 10 = 3
// 3：十位的计算：数值 / 10 % 10
int shi = num / 10 % 10; // 123 / 10 = 12 12 % 10 = 2
// 4：百位的计算：数值 / 100
int bai = num / 100; // 123 / 100 = 1
// 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
System.out.println("整数:"+num+" 个位为:" + ge);
System.out.println("整数:"+num+" 十位为:" + shi);
System.out.println("整数:"+num+" 百位为:" + bai);
}
}“+”号的两种用法
- 第一种：对于
+两边都是数值的话，+就是加法的意思。char类型参与算术运算，使用的是计算机底层对应的十进制数值。 - 第二种：对于
+两边至少有一边是字符串得话，+就是拼接的意思。字符串可以使用 +号, 跟任意数据类型拼接，结果就是字符串。当连续进行“+”操作时，从左到右逐个执行。能算则算，不能算则拼接在一起。变量运算是取其中保存的值。
代码示例
public class Demo02Operator {
public static void main(String[] args) {
//数学中的加法运算(数字相加,字符相加)
System.out.println(5 + 5);// 10
/*
int + char ==> int + int ==> int
需要:
char ==> int 查看ASCII码表 'A'对应65
*/
System.out.println(5 + 'A');// 70
/*
自动类型转换中:
byte/short/char类型,只要参加运算,会自动转换为int类型
char + char ==> int + int ==> int
需要:
char ==> int 查看ASCII码表 'A'对应65
char ==> int 查看ASCII码表 'B'对应66
*/
System.out.println('A' + 'B');// 131
//字符串的拼接(把两个字符串连在一起),从左向右计算
System.out.println("Hello" + "World"); //HelloWorld
//先计算"5+5="+5: 此处+号代表字符串的连接 结果是"5+5=5"
//然后"5+5=5"+5: 此处+号代表字符串的连接 结果是"5+5=55"
System.out.println("5+5=" + 5 + 5);//5+5=55
// 可以使用小括号提高运算的等级,所以先计算5+5 结果10
//然后"5+5="+10: 此处+号代表字符串的连接 结果是"5+5=10"
System.out.println("5+5=" + (5 + 5));//5+5=10
}
}自增自减运算符
++运算，变量自己的值加1。反之，--运算，变量自己的值减少1- ++ 和 -- 既可以放在变量的后边，也可以放在变量的前边。
- 自增自减运算符只能操作变量，不能操作常量
单独使用（推荐使用）
变量在单独运算的时候，变量前++和变量后++，是没有任何区别的；
- 变量前++ ：例如 ++a
- 变量后++ ：例如 a++
代码示例
public static void main(String[] args) {
// 定义一个int类型的变量a
int a = 3;
//++a;
a++;
// 无论是变量前++还是变量后++，结果都是4
System.out.println(a);
}复合使用
和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
- 变量前++ ：放在变量的前面，先对变量进行+1，再拿变量的值进行运算
- 变量后++ ：放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1
public class Demo04Operator {
public static void main(String[] args) {
// 其他变量放在一起使用
int x = 3;
//int y = ++x; y的值是4，x的值是4，
// y的值是3，x的值是4
int y = x++;
System.out.println(x);//4
System.out.println(y); //3
// 和输出语句一起
int z = 5;
System.out.println(++z);//6
System.out.println(z++);// 6
System.out.println(z);//7
int a = 1;
//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1
a = a++;
System.out.println(a);//1
}
}实际开发中强烈建议不要写这样的代码
public static void main(String[] args) {
int x = 4;
/*
表达式(x++)+(++x)+(x*10)是从左到右计算的
先计算(x++): 因为++在后面,先使用x的值4,然后x的值增加,变成5
4 + (++x)+(x*10)
接着计算(++x): 因为++在前面,先把x的值增加1,x变成6,然后再使用6
4 + 6+(x*10)
接着计算x*10 --> 6*10 结果: 60
4 + 6 + 10 结果: 70
*/
int y = (x++) + (++x) + (x * 10);
System.out.println(x);//6
System.out.println(y);//70
}赋值运算符
- 赋值运算符，就是将符号右边的值，赋给左边的变量。 所有的赋值运算符的左边一定是一个变量，不能是常量。
- 基本赋值运算符，就是“=”。
int a = 10; // 先看“=”右边，把数据10赋值给左边的变量a存储。扩展赋值运算符
代码示例
/*
基本赋值运算符: =
复合赋值运算符:
+= a+=b a=a+b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
*/
public class Demo03Operator {
public static void main(String[] args) {
//基本赋值运算符
int a = 10, b = 20;
//复合赋值运算符:
a += b;//a = a + b
System.out.println(a);//30
System.out.println(b);//20
int c = 30, d = 20;
c %= d;//c = c % d
System.out.println(c);//10
System.out.println(d);//20
short s = 1;
/*
+=,-=,/=,*=,%= 运算结果的数据类型和左侧变量的数据类型不一致,隐藏强制类型转换
*/
s += 1;//s = (short)(s + 1);
System.out.println(s);//2
}
}注意事项：
- 扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。
- 整数常量只要不超出所赋值的整数变量的取值范围,可以直接赋值,内部隐藏强制类型转换
- 运算的顺序：把右边的整个表达式先算完，才会做最后的赋值操作。
例如：
int j = 1;
j += ++j * j++;//相当于 j = j + (++j * j++);
System.out.println(j);//5关系运算符
- 关系运算符又可以叫比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false
代码示例
public class Demo05Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true
// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag);// false
}
}注意事项：
- 其中>,<,>=,<=不支持boolean，String类型。==和!=支持boolean和String。
- 千万不要把“==”误写成“=”，"=="是判断是否相等的关系，"="是赋值。
逻辑运算符
- 逻辑运算符，是用来连接多个布尔类型结果的运算符（
!除外），运算结果一定是boolean值true或者false。 - 逻辑运算符作用: 用于整合多个比较表达式的条件
代码示例、
public class Demo6Operator {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((a > b) & (a > c)); //false
System.out.println((a > b) & (a < c)); //false
System.out.println((a < b) & (a > c)); //false
System.out.println((a < b) & (a < c)); //true
// | “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((a > b) | (a > c)); //false
System.out.println((a > b) | (a < c)); //true
System.out.println((a < b) | (a > c)); //true
System.out.println((a < b) | (a < c)); //true
// ^ 异或；相同为false，不同为true
System.out.println((a > b) ^ (a > c)); //false
System.out.println((a > b) ^ (a < c));//true
System.out.println((a < b) ^ (a > c));//true
System.out.println((a < b) ^ (a < c)); //false
// ! 非；非false则true，非true则false
System.out.println(!false); //true
System.out.println(!true); //false
}
}短路逻辑运算符
- 在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值 都计算出来，短路与操作就有这样的效果，可以提高效率。
- 同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
&& 和& 区别：
- &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。
|| 和 | 区别：
- ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。
代码示例
/*
逻辑运算符的短路效果
1.短路的逻辑运算符
(1)短路逻辑与&&: 左侧为false,右边不计算
(2)短路逻辑或||: 左侧为true,右侧不计算
2.特点:
(1)短路逻辑与&&: 和&结果是相同的,但是&&可以提高效率
(2)短路逻辑与||: 和|结果是相同的,但是||可以提高效率
*/
public class Demo08Operator {
public static void main(String[] args) {
int a = 2;
/*
整个表达式(3>5)&&(++a>2)从左向右计算
先计算表达式3>5结果为false
因为两个表达式使用&&连接,左侧为false,已经决定了最终的结果为false,
不管右侧表达式(++a>2)的结果是true还是false,都无法改变&&的最终结果,
所以右侧表达式(++a>2)不进行计算
*/
System.out.println((3 > 5) && (++a > 2));//false
System.out.println(a);//2: 说明++a没有计算,&&右侧的表达式没有执行
int b = 2;
/*
整个表达式(3>5)&(++b>2)从左向右计算
先计算表达式3>5结果为false
因为两个表达式使用&连接,左侧为false,虽然已经决定了最终的结果为false,
但是右侧表达式(++b>2)仍然要进行计算,所以b的值最终是3
*/
System.out.println((3 > 5) & (++b > 2));//false
System.out.println(b);//3: 说明++b进行计算,&右侧的表达式执行了
System.out.println("-------------------");
int c = 2;
/*
整个表达式(3<5)||(++c>2)从左向右计算
先计算表达式3<5结果为true
因为两个表达式使用||连接,左侧为true,已经决定了最终的结果为true,
不管右侧表达式(++c>2)的结果是true还是false,都无法改变||的最终结果,
所以右侧表达式(++c>2)不进行计算
*/
System.out.println((3 < 5) || (++c > 2));//true
System.out.println(c);//2: 说明++c没有计算,||右侧的表达式没有执行
int d = 2;
/*
整个表达式(3<5)|(++d>2)从左向右计算
先计算表达式3<5结果为true
因为两个表达式使用|连接,左侧为true,虽然已经决定了最终的结果为true,
但是右侧表达式(++d>2)仍然要进行计算,所以d的值最终是3
*/
System.out.println((3 < 5) | (++d > 2));//true
System.out.println(d);//3: 说明++d进行计算,|右侧的表达式执行了
}
}三元运算符
语法格式：
- 数据类型 变量名称 = 布尔表达式1 ? 表达式2 : 表达式3;
执行流程:
- 计算布尔表达式1的结果,看是true还是false
- 如果布尔表达式1的结果为true,就把表达式2的结果赋值给左侧的变量
- 如果布尔表达式1的结果为false,就把表达式3的结果赋值给左侧的变量
执行流程图解:
代码示例
/*
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。
分析：
① 用三元运算符获取前两个身高数的最大值，并用临时变量保存起来。
② 用三元运算符，让临时最大值，和第三个身高，进行比较，并记录结果。
③ 输出结果
*/
public class Demo08Operator {
public static void main(String[] args) {
//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
int h1 = 150;
int h2 = 210;
int h3 = 165;
//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
int temp = h1 > h2 ? h1 : h2;
//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
int max = temp > h3 ? temp : h3;
//4：输出结果
System.out.println("这三个和尚中身高最高的是：" + max + "cm");
}
}位运算（了解）
效率很高，但是可读性不好。因为它是基于二进制补码直接运算的。关于&,|,^，看左右两边的操作数是boolean值，还是整数，来决定是逻辑运算符还是位运算符。常见的有以下几种位运算符
左移：<<
- 运算规则：<<几位，就乘以2的几次方
- 二进制补码左移n位，右边补0
右移：>>
- 运算规则：>>几位，就除以2的几次方
- 二进制补码右移n位，左边补0还是1，看最高位
无符号右移：>>>
- 运算规则：二进制补码右移n位，左边补0，对于负数来说，移完后，变为正数
运算符优先级
在表达式中，哪个运算符先执行后执行是要看优先级的，例如 “ *、/” 的优先级高于”+、-” 。运算符优先级如下图所示：
我们遵循一个原则：
- 表达式不要写太复杂，可以分为多行
- 实际开发中都是使用小括号来调整运算优先级
案例
// 目标：看看Java是否存在优先级，大家以后需要注意优先级问题
System.out.println(10 > 3 || 10 > 3 && 10 < 3); // true
System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false
