运算符:
就是对常量和变量进行操作的符号。
算数运算符:
A:+,-,*,/,%,++,--
B:+的用法
a:加法
b:正号
c:字符串连接符
C:/和%的区别
数据做除法操作的时候,/取得是商,%取得是余数
D:++和--的用法
a:他们的作用是自增或者自减
b:使用
**单独使用
放在操作数据的前面和后面效果一样。
a++或者++a效果一样。
**参与操作使用
放在操作数的前面:先自增或者自减,再参与操作
int a = 10;
int b = ++a;
放在操作数的后面:先参与操作,再自增或者自减
int a = 10;
int b = a++;
public static void main(String[] args) {
//定义变量
int x = 3; //把3赋值给int类型的变量x
int y = 4;
System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y); //整数相除只能得到整数
//我就想得到小数,该肿么办呢?
//只需要把操作的数据中任意的一个数据变为浮点数
System.out.println(x*1.0/y);
//%的应用
System.out.println(x%y); //得到的是余数
}
注意事项:
A:整数相除只能得到整数。如果想得到小数,必须把数据变化为浮点数类型
B:/获取的是除法操作的商,%获取的是除法操作的余数
++;--的使用:就是对变量进行自增或者自减1
单独使用:
放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
参与运算使用:
放在操作数的前面,先自增或者自减,然后再参与运算。
放在操作数的后面,先参与运算,再自增或者自减。
code: |
public static void main(String[] args) { //定义两个变量 int x = 3; int y = 4;
//字符串的拼接 //System.out.println("x:"+x); //System.out.println("y:"+y);
System.out.println("x:"+x+",y:"+y);
//单独使用 //x++; //y--; ++x; --y; //System.out.println(x); System.out.println("x:"+x+",y:"+y);
//意外的类型,常量是不可以这样做的 //System.out.println(10++);
System.out.println("-------------------"); //参与运算使用 int a = 3; int b = 4;
//int c = a++; //int d = b--;
int c = ++a; int d = --b;
System.out.println("a:"+a); //4, 4 System.out.println("b:"+b); //3, 3 System.out.println("c:"+c); //3, 4 System.out.println("d:"+d); //4, 3 } |
demo: |
/* ++,--
第一题: int a = 10; int b = 10; int c = 10;
a = b++; c = --a; b = ++a; a = c--; 请分别计算出a,b,c的值
第二题: int x = 4; int y = (x++)+(++x)+(x*10); 请分别计算出x,y的值 */ class OperatorTest { public static void main(String[] args) { int a = 10; int b = 10; int c = 10;
a = b++; //a=10,b=11,c=10 c = --a; //a=9,b=11,c=9 b = ++a; //a=10,b=10,c=9 a = c--; //a=9,b=10,c=8
System.out.println("a:"+a); System.out.println("b:"+b); System.out.println("c:"+c); System.out.println("--------------");
int x = 4; int y = (x++)+(++x)+(x*10); //4+6+60 //x=5,6
System.out.println("x:"+x); System.out.println("y:"+y); } } |
+号的用法:
A:加法
B:正号
C:字符串连接符
code: |
public static void main(String[] args) { //加法 System.out.println(3+4);
//正号 System.out.println(+4);
System.out.println('a'); System.out.println('a'+1); //这里是加法
//字符串连接符 System.out.println("hello"+'a'+1); System.out.println('a'+1+"hello"); } |
赋值运算符:
基本的赋值运算符:=
把=右边的数据赋值给左边。
扩展的赋值运算符:+=,-=,*=,/=,%=
+= 把左边和右边做加法,然后赋值给左边。
code: |
public static void main(String[] args) { //定义一个变量 int x = 10;
//其他用法 int a,b; a = b = 10; System.out.println(a); System.out.println(b); System.out.println("-----------");
//定义一个变量 int y = 10;
y += 20;
System.out.println(y);
} |
code |
/* short s=1;s = s+1;
short s=1;s+=1; 上面两个代码有没有问题,如果有,那里有问题。
为什么第二个木有问题呢? 扩展的赋值运算符其实隐含了一个强制类型转换。
s += 1; 不是等价于 s = s + 1; 而是等价于 s = (s的数据类型)(s + 1); */ class OperatorTest { public static void main(String[] args) { //short s = 1; //s = s + 1; //System.out.println(s);
short s = 1; s += 1; //好像是 s = s + 1; System.out.println(s); } } |
比较运算符:
比较运算符:
==,!=,>,>=,<,<=
特点:
无论你的操作是简单还是复杂,结果是boolean类型。
注意事项:
"=="不能写成"="。
code |
public static void main(String[] args) { int x = 3; int y = 4; int z = 3;
System.out.println(x == y); System.out.println(x == z); System.out.println((x+y) == (x+z)); System.out.println("------------");
System.out.println(x != y); System.out.println(x > y); System.out.println(x >= y); System.out.println(x < y); System.out.println(x <= y); System.out.println("------------");
int a = 10; int b = 20;
//boolean flag = (a == b); //boolean flag = (a = b); //这个是有问题的,不兼容的类型 //System.out.println(flag);
int c = (a = b); //把b赋值给a,然后把a留下来 System.out.println(c); } |
逻辑运算符:
逻辑运算符:
&,|,^,!
&&,||
特点:
逻辑运算符一般用于连接boolean类型的表达式或者值。
表达式:就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式:a + b
比较表达式:a == b
结论:
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false,不同为true。
举例:情侣关系。男男,男女,女男,女女
!逻辑非:非false则true,非true则false。
特点:偶数个不改变本身。
code |
public static void main(String[] args) { int a = 3; int b = 4; int c = 5;
//&逻辑与 System.out.println((a > b) & (a > c)); //false & false = false System.out.println((a > b) & (a < c)); //false & true = false System.out.println((a < b) & (a > c)); //true & false = false System.out.println((a < b) & (a < c)); //true & true = true System.out.println("---------------");
//|逻辑或 System.out.println((a > b) | (a > c)); //false | false = false System.out.println((a > b) | (a < c)); //false | true = true System.out.println((a < b) | (a > c)); //true | false = true System.out.println((a < b) | (a < c)); //true | true = true System.out.println("---------------");
//^逻辑异或 System.out.println((a > b) ^ (a > c)); //false ^ false = false System.out.println((a > b) ^ (a < c)); //false ^ true = true System.out.println((a < b) ^ (a > c)); //true ^ false = true System.out.println((a < b) ^ (a < c)); //true ^ true = false System.out.println("---------------");
//!逻辑非 System.out.println(!(a > b)); //!false = true System.out.println(!(a < b)); //!true = false System.out.println(!!(a > b)); //!!false = false System.out.println(!!!(a > b)); //!!false = true |
code: &&和&的区别? 同理||和|的区别? A:最终结果一样。 B:&&具有短路效果。左边是false,右边不执行。
开发中常用的逻辑运算符: &&,||,! |
public static void main(String[] args) { int a = 3; int b = 4; int c = 5;
//&&双与 System.out.println((a > b) && (a > c)); //false && false = false System.out.println((a > b) && (a < c)); //false && true = false System.out.println((a < b) && (a > c)); //true && false = false System.out.println((a < b) && (a < c)); //true && true = true System.out.println("----------------");
int x = 3; int y = 4;
//boolean b1 = ((x++ == 3) & (y++ == 4)); //boolean b1 = ((x++ == 3) && (y++ == 4)); //boolean b1 = ((++x == 3) & (y++ == 4)); boolean b1 = ((++x == 3) && (y++ == 4)); System.out.println("x:"+x); System.out.println("y:"+y); System.out.println(b1); } |
位运算符:
&,|,^,~
<<,>>,>>>
要做位运算,首先要把数据转换为二进制
code: |
public static void main(String[] args) { //&,|,^,~
int a = 3; int b = 4;
System.out.println(3 & 4); System.out.println(3 | 4); System.out.println(3 ^ 4); System.out.println(~3); } |
分析:因为是位运算,所以我们必须先把数据换算成二进制。
3的二进制:11 00000000 00000000 00000000 00000011 4的二进制:100 00000000 00000000 00000000 00000100
&位与运算:有0则0。 00000000 00000000 00000000 00000011 &00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000000 结果是:0
|位或运算:有1则1。 00000000 00000000 00000000 00000011 |00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000111 结果是:7
^位异或运算:相同则0,不同则1。 00000000 00000000 00000000 00000011 &00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000111 结果是:7
~按位取反运算符:0变1,1变0 00000000 00000000 00000000 00000011 ~11111111 11111111 11111111 11111100 (补码)
补码:11111111 11111111 11111111 11111100 反码:11111111 11111111 11111111 11111011 原码:10000000 00000000 00000000 00000100 结果是:-4 |
^的特点:一个数据对另一个数据位异或两次,该数本身不变。
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a ^ b ^ b); //10
System.out.println(a ^ b ^ a); //20
}
code:请自己实现两个整数变量的交换 |
//方式1:使用第三方变量(开发中用的) /* int c = a; a = b; b = c; System.out.println("a:"+a+",b:"+b); System.out.println("------------"); */
//方式2:用位异或实现(面试用) //左边:a,b,a //右边:a ^ b /* a = a ^ b; b = a ^ b; //a ^ b ^ b = a a = a ^ b; //a ^ b ^ a = b System.out.println("a:"+a+",b:"+b); */
//方式3:用变量相加的做法 /* a = a + b; //a=30 b = a - b; //b=10 a = a - b; //a=20 System.out.println("a:"+a+",b:"+b); */
//方式4:一句话搞定 b = (a+b) - (a=b); //b=30-20=10,a=20 System.out.println("a:"+a+",b:"+b); |
|
<<:左移 左边最高位丢弃,右边补齐0
>>:右移 最高位是0,左边补齐0;最高为是1,左边补齐1
>>>:无符号右移 无论最高位是0还是1,左边补齐0
code: |
public static void main(String[] args) { //<< 把<<左边的数据乘以2的移动次幂 System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
//>> 把>>左边的数据除以2的移动次幂 System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6 System.out.println(24 >>> 2);
System.out.println(-24 >> 2); System.out.println(-24 >>> 2); } } /* 计算出3的二进制:11 00000000 00000000 00000000 00000011 (00)000000 00000000 00000000 0000001100
>>的移动: 计算出24的二进制:11000 原码:10000000 00000000 00000000 00011000 反码:11111111 11111111 11111111 11100111 补码:11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000 1111111111 11111111 11111111 111010(00) 补码
补码:1111111111 11111111 11111111 111010 反码:1111111111 11111111 11111111 111001 原码:1000000000 00000000 00000000 000110
结果:-6
>>>的移动: 计算出24的二进制:11000 原码:10000000 00000000 00000000 00011000 反码:11111111 11111111 11111111 11100111 补码:11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000 0011111111 11111111 11111111 111010(00)
结果: */ |
三元(目)运算符:
格式:
比较表达式?表达式1:表达式2;
比较表达式:结果是一个boolean类型。
执行流程:
根据比较表达式的计算返回一个true或者false。
如果是true,就把表达式1作为结果。
如果是false,就把表达式2作为结果。
code: |
public static void main(String[] args) { int x = 100; int y = 200;
int z = ((x > y)? x: y);
//int z = ((x < y)? x: y);
//int z = ((x == y)? x: y);
//报错 //int z = ((x = y)? x : y);
System.out.println("z:"+z); } |
code: 获取两个整数中的最大值 获取三个整数中的最大值 比较两个整数是否相同
|
public static void main(String[] args) { //获取两个整数中的最大值 int x = 100; int y = 200;
int max = (x > y? x: y); System.out.println("max:"+max); System.out.println("--------");
//获取三个整数中的最大值 int a = 10; int b = 30; int c = 20;
//分两步: //A:先比较a,b的最大值 //B:拿a,b的最大值在和c进行比较 int temp = ((a > b)? a: b); //System.out.println(temp); int max1 = (temp > c? temp: c); System.out.println("max1:"+max1);
//一步搞定 //int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c); //这种做法不推荐。 //int max2 = a > b?a > c? a: c:b > c? b: c; //System.out.println("max2:"+max2); System.out.println("--------");
//比较两个整数是否相同 int m = 100; int n = 200;
//boolean flag = (m == n)? true: false; boolean flag = (m == n); System.out.println(flag); } |