(1)算术运算符
A:+,-,*,/,%,++,-- B:+的用法 a:加法 b:正号 c:字符串连接符 C:/和%的区别 数据做除法操作的时候，/取得是商，%取得是余数 D:++和--的用法 a:他们的作用是自增或者自减 b:使用 **单独使用 放在操作数据的前面和后面效果一样。 a++或者++a效果一样。 **参与操作使用 放在操作数的前面：先自增或者自减，再参与操作 int a = 10; int b = ++a; 放在操作数的后面：先参与操作，再自增或者自减 int a = 10; int b = a++;
/和%的区别：
/* 注意事项： A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型 B:/获取的是除法操作的商，%获取的是除法操作的余数 */ class OperatorDemo { 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); //得到0，整数相除只能得到整数 //我就想得到小数，该肿么办呢? //只需要把操作的数据中任意的一个数据变为浮点数 System.out.println(x*1.0/y); //%的应用 System.out.println(x%y); //得到的是余数 } }
++,--运算符的使用;
/* ++,--运算符的使用： 单独使用： 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的) 参与运算使用： 放在操作数的前面，先自增或者自减，然后再参与运算。 放在操作数的后面，先参与运算，再自增或者自减。 作用：就是对变量进行自增1或者自减1。 */ class OperatorDemo2 { 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 } }
运算符的优先级：
+的用法：
/* +的用法： A:加法 B:正号 C:字符串连接符 */ class OperatorDemo3 { public static void main(String[] args) { //加法 System.out.println(3+4); //正号 System.out.println(+4); System.out.println('a');//直接输出字符a System.out.println('a'+1); //字符a和1的加法，这里是加法输出98 //字符串连接符，注意是字符串而不是字符 System.out.println("hello"+'a'+1);//helloa1，字符串hello和字符a链接，得到字符串helloa，再和链接 System.out.println('a'+1+"hello");//98hello，先进行字符a和1的加法运算，再和字符串hello链接 } }
(2)赋值运算符
(2)赋值运算符 A:=,+=,-=,*=,/=,%=等 B:=叫做赋值运算符，也是最基本的赋值运算符 int x = 10; 把10赋值给int类型的变量x。 C:扩展的赋值运算符的特点 隐含了自动强制转换。 例子： short s = 1; s = s + 1; short s = 1; s += 1; 请问上面的代码哪个有问题?
赋值运算符：
/* 赋值运算符： 基本的赋值运算符：= 把=右边的数据赋值给左边。 扩展的赋值运算符：+=,-=,*=,/=,%= += 把左边和右边做加法，然后赋值给左边。 */ class OperatorDemo { public static void main(String[] args) { //定义一个变量 int x = 10; //其他用法 int a,b; a = b = 10;//把10赋给b,再把b赋值给a。这种写法不建议 System.out.println(a); System.out.println(b); System.out.println("-----------"); //定义一个变量 int y = 10; y += 20;//y = y + 20 System.out.println(y); } }
扩展的赋值运算符其实隐含了一个强制类型转换：
/* 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); //s = s + 1;//short类型，先转成int,和1相加，再赋值给short类型，报错 short s = 1; s += 1; //好像是 s = s + 1; System.out.println(s); } }
(3)比较运算符
/* 比较运算符： ==,!=,>,>=,<,<= 特点： 无论你的操作是简单还是复杂，结果是boolean类型。 注意事项： "=="不能写成"="。 */ class OperatorDemo { 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); //这个是有问题的，不兼容的类型。 //把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，报错 //System.out.println(flag); int c = (a = b); //把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，出错 System.out.println(c);
(4)逻辑运算符
A:&,|,^,!,&&,|| B:逻辑运算符用于连接boolean类型的式子 C:结论 &:有false则false |:有true则true ^:相同则false，不同则true。 情侣关系。 !:非true则false，非false则true &&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。 ||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。
/* 逻辑运算符： &,|,^,! &&,|| 特点： 逻辑运算符一般用于连接boolean类型的表达式或者值。 表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。 算术表达式：a + b 比较表达式：a == b 结论： &逻辑与:有false则false。 |逻辑或:有true则true。 ^逻辑异或:相同为false，不同为true。 举例：情侣关系。男男,男女,女男,女女 !逻辑非:非false则true，非true则false。 特点：偶数个不改变本身。 */ class OperatorDemo { 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 } }
&&和&的区别? 同理||和|的区别?
/* &&和&的区别? 同理||和|的区别? A:最终结果一样。 B:&&具有短路效果。左边是false，右边不执行。 开发中常用的逻辑运算符： &&,||,! */ class OperatorDemo2 { 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); } }
位运算
(5)位运算符(了解) A:^的特殊用法 一个数据针对另一个数据位异或两次，该数不变 B:实例 a:请实现两个变量的交换 **采用第三方变量 **用位异或运算符 左边a,b,a 右边a^b b:请用最有效率的方式计算出2乘以8的结果 2<<3
位运算符：&,|,^,~ 解释
/* 位运算符： &,|,^,~ <<,>>,>>> 注意： 要做位运算，首先要把数据转换为二进制。 */ class OperatorDemo { 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，针对补码 在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用补码进行的。 原码：就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。 反码： 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。 补码 正数的补码与其原码相同；负数的补码是在其反码的末位加1。 00000000 00000000 00000000 00000011 //正数的原码、反码、补码相同，这里代表3的补码 ~11111111 11111111 11111111 11111100 (补码) ~3 按位对3的补码取反得到的 //下面通过补码，求得原码 补码：11111111 11111111 11111111 11111100 反码：11111111 11111111 11111111 11111011 原码：10000000 00000000 00000000 00000100 结果是：-4 */
^异或的特点：一个数据对另一个数据位异或两次，该数本身不变。
/* ^的特点：一个数据对另一个数据位异或两次，该数本身不变。 比如b对a异或两次，a数本身不变。 可以用来简单加密 */ class OperatorDemo2 { 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 } }
实现两个整数变量的交换：
/* 实例： 实现两个整数变量的交换 */ class OperatorTest { public static void main(String[] args) { int a = 10; int b = 20; System.out.println("a:"+a+",b:"+b); //方式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 //先把b赋值给a，然后用和减去a得到b System.out.println("a:"+a+",b:"+b); } }
位移运算
/* <<:左移 左边最高位丢弃，右边补齐0 >>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1 >>>:无符号右移 无论最高位是0还是1，左边补齐0 请用最有效率的方式写出计算2乘以8的结果? 2 * 8 2 << 3 */ class OperatorDemo3 { 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 -24原码：10000000 00000000 00000000 00011000 反码：11111111 11111111 11111111 11100111 补码：11111111 11111111 11111111 11101000 //>>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1 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)//这里原、反、补都相同 结果： */
三目运算
/* 单目运算符：~3 双目运算符：3 + 4 三目运算符： 格式：比较表达式?表达式1:表达式2; 比较表达式:结果是一个boolean类型。 执行流程： 根据比较表达式的计算返回一个true或者false。 如果是true，就把表达式1作为结果。 如果是false，就把表达式2作为结果。 */ class OperatorDemo { 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);//表达式是布尔类型，才能判断。这里把y赋值给x，而x是int类型 System.out.println("z:"+z); } }
获取最大值，判断值是否相等
/* 练习： 获取两个整数中的最大值 获取三个整数中的最大值 比较两个整数是否相同 */ class OperatorTest { 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); } }