Java运算符

一向迷人

已于 2024-04-25 16:22:31 修改

阅读量1.8k

点赞数 47

文章标签： java python 开发语言

于 2024-04-24 13:51:53 首次发布

本文链接：https://blog.csdn.net/m0_73519615/article/details/138157047

版权

Java运算符

文章目录

- - Java运算符

算数运算符：

加运算： +

减运算： -

乘运算： *

除运算： /

取余符： %

自增1 ：++

自减1 ： –

算数运算符的使用

		算数运算符的使用：+，-，*，/，%，++，--
		
		System.out.println(10+1); //11
		System.out.println(10-1); //9
		System.out.println(10*3); //30
		System.out.println(10/3); //3
		System.out.println(10%3); //1
		
		//++：自加
		int a = 10;
		//a++ : 先使用，后自增1
		System.out.println(a++); //10
		System.out.println(a); //11
		
		int b = 10;
		//++b : 先自增1，再使用
		System.out.println(++b); //11
		System.out.println(b); //11
		
		
		// -- ： 自减1操作
		int a = 10;
		//a--: 先使用再自减1
		System.out.println(a--); //10
		System.out.println(a); //9
		
		int b=10;
		//--b ：先自减1，再使用
		System.out.println(--b);//9
		System.out.println(b);//9

算数运算符的特殊点

//特殊点1：byte做运算，会向上转型成int，再做运算
		byte b1 = 10;
		byte b2 = 20;
		
		//b1 -- byte：0000,1010
		//	   (int)：0000,0000,0000,0000,0000,0000,0000,1010
		//b2 -- byte：0001,0100
		//	   (int)：0000,0000,0000,0000,0000,0000,0001,0100
		//	     结果：0000,0000,0000,0000,0000,0000,0001,1110
		//	  (byte)：0001,1110
		byte result = (byte)(b1+b2);
		
		System.out.println(result);

//特殊点2：short做运算，会向上转型成int，再做运算
		//s1 -- short：0000,0000,0000,1010
		//	    (int)：0000,0000,0000,0000,0000,0000,0000,1010
		//s2 -- short：0000,0000,0001,0100
		//	    (int)：0000,0000,0000,0000,0000,0000,0001,0100
		//	     结果：0000,0000,0000,0000,0000,0000,0001,1110
		//	  (short)：0000,0000,0001,1110
		short s1 = 10;
		short s2 = 20;
		short result = (short)(s1+s2);
		
		System.out.println(result);

//特殊点3：除了byte和short做运算会转型成int，其他数值类型做运算会按照取值范围大的类型转型后再做运算
		byte b = 10;
		short s = 10;
		int i = 10;
		long l = 10;
		float f = 10;
		double d = 10;
		
		System.out.println(b + b);//结果是int类型
		System.out.println(b + s);//结果是int类型
		System.out.println(b + i);//结果是int类型
		System.out.println(s + i);//结果是int类型
		System.out.println(i + l);//结果是long类型
		System.out.println(s + l);//结果是long类型
		System.out.println(i + f);//结果是float类型
		System.out.println(l + f);//结果是float类型
		System.out.println(l + d);//结果是double类型
		System.out.println(f + d);//结果是double类型

//特殊点4：浮点类型做运算可能会失去精度，失去精度问题可以使用BigInteger或BigDecimal去解决
		double d1 = 0.5;
		double d2 = 0.4;
		System.out.println(d1 - d2);//0.09999999999999999998

//特殊点5：++a; 和 a++; 没有区别，因为分号为执行语句的结束符，不管先加还是后加都给我自增1
		int a = 10;
		//++a;
		a++;
		System.out.println(a);//11

//特殊点6：++底层会强转
		int a = 10;
		++a;//底层实现：a = (int)(a+1);
		System.out.println(a);//11

//特殊点7：char类型可以做算数运算
		char c = 'a';//'a'字符的码值是97
		System.out.println(c+1);//98

//特殊点8：boolean不能与其他类型兼容
		boolean bool = true;
		System.out.println(bool + 1);

经典面试题加拓展

//经典面试题一：输出结果为？
			int a = 8;
			int b = (a++)+(++a)+(a*10);
			//a = 10
			//b = 8 + 10 + 100
			System.out.println(b);//118

//经典面试题二：输出结果为？
int  i =  0 ;   
i = ++i;   //i=(int) i+1
System.out.println(i);//1

经典面试题三：输出结果为？
			int i = 0;   
			//底层原理：
			//int temp = i; -- temp作为临时变量，记录了i最初始的值 - 0
			//i = (int)(i+1); -- 变量i确实自增了
			//i = temp; -- 将temp赋值给i，i又变回了原来的值
			i = i++; 
			System.out.println(i);//0

赋值运算符

= ，+= ，-= ，*= ，/= ，%=

赋值规则：
s += 1 s = (short)((s) + (1))
复合赋值 E1 op= E2等价于简单赋值 E1 = (T)((E1) op (E2))，其中T是E1的类型。

案例：

int num = 10;
		
		num += 5;//num = (int)(num+5);
		num -= 5;//num = (int)(num-5);
		num *= 5;//num = (int)(num*5);
		num /= 5;//num = (int)(num/5);
		num %= 3;//num = (int)(num%3);
		System.out.println(num);//1

//经典面试题：下面的两种写法结果分别是？
			short s = 1; 
			s = s+1;//会报错，因为short类型的数据和int类型的数据做运算，会向上转型成int

			short s=1; 
			s += 1;//不会报错 //s= (short) (s+1)

关系运算符

== ,!= ,> ,>= ,< ,<=

关系运算符的结果都是boolean类型的值
= 是赋值运算符，是将右边的值赋值给左边变量
== 是关系运算符，判断两边的值是否相等
!= 是关系运算符，判断两边的值是否不相等

使用案例：

boolean bool = 10 == 5;
		System.out.println(bool);//false
		System.out.println(10 != 5);//true
		System.out.println(10 >  5);//true
		System.out.println(10 >= 5);//true
		System.out.println(10 <  5);//false
		System.out.println(10 <= 5);//false

经典面试题

//经典面试题一：输出结果为？
			int x = 10;
			int y = 10;
			boolean flag = (x == y);
			System.out.println(flag);//true
			flag = (x = y);//会报错，因为boolean类型不能与其他类型兼容
			System.out.println(flag);

//经典面试题二：输出结果为？
			boolean b1 = true;
			boolean b2 = false;
			boolean b3 = (b1 == b2);
			System.out.println(b3);//false
			boolean b4 = (b1 = b2);
			System.out.println(b4);//false

字符串拼接符

符号：+

注意：当 + 的两边都是数值型的时候，+ 是算数运算符

当 + 的两边有字符串的话，+这时就是字符串拼接符

		  System.out.println(1+2+""+8+"a");
							//3+""+8+"a"
							// "3"+8+"a"
							 //"38"+"a"
							 //  "38a"

逻辑运算符

符号：

& 与 && 短路与

| 或 || 短路或

^ 异或

! 非

理解：

& 与，&& 短路与：前后都接boolean值，前后都成立结果才能成立（true）

& 与：判断前面结果为false之后还会去执行后面的。
&& 短路与：判断前面的结果为false之后不回去执行后面的

		System.out.println(true & true); //true
		System.out.println(true && false);//false
		System.out.println(false & false); //false
		System.out.println(false && true); //false
		//测试
		System.out.println(false & 10/0>3); //报错，说明执行了后面的10/0>3
		// && 短路与：判断前面的值为false之后就不去执行后面的语句了
		//测试
		System.out.println(false &&10/0>3); //false ，没有执行后面语句

| 或，|| 短路或：前后都接boolean值，只要有其中一个为true，则其结果就是true

| 或：判断前面的值为true，还会执行后面的语句

|| 短路或：判断前面的值为true，就不会去执行后面的语句

System.out.println(true | true); //true
		System.out.println(true || false);//true
		System.out.println(false | false); //false
		System.out.println(false || true); //true
		
		//测试
		System.out.println(true || 10/0>3); //true ,没有执行后面的
		System.out.println(true | 10/0>3); //报错，执行了后面的

^ 异或：前面都接boolean值，前后的值不同为true，相同为false

	System.out.println(true ^ true); //false
		System.out.println(true ^ false);//true
		System.out.println(false ^ false); //false
		System.out.println(false ^ true); //true

! 非：取反，置反

            boolean a = true;
            System.out.println(!a); //false
            boolean b = false;
            System.out.println(!a); //true

练习题：在dos窗口输入一个数字，判断是否在50~100的区间内

            Scanner sc = new Scanner(System.in);

            System.out.println("请输入数字：");
            int num = sc.nextInt();

            boolean n = num>=50 && num<=100;
            System.out.println("输入的数字是否在50~100的区间内：" + n);

三目运算/三元运算

语法格式：变量= (判断表达式) ？值1 ：值2

理解：

表达式成立 ----将值1赋值给变量
表达式不成立–将值2赋值给变量

使用测试：

		int s = (4>3)? 10 : 20;
		System.out.println(s); //10
		int n = (4>5)? 10 :20;
		System.out.println(n); //20

返回值规则：

值1和值2都是常量的情况，按照取值范围大的类型返回数据
值1和值2都是变量的情况，按照取值范围大的类型返回数据
值1和值2一个是变量一个是常量的情况，判断常量是否在变量所属类型的取值范围里
a. 在 – 按照变量类型返回数据
b. 不在 - 按照常量类型返回数据

案例：

//需求1：在控制台输入三个int值，输出最大值
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入第一个数字：");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字：");
		int b = scan.nextInt();
		System.out.println("请输入第三个数字：");
		int c = scan.nextInt();
		
		int max = (a>b)?a:b;
		max = (max>c)?max:c;
		System.out.println("最大值为：" + max);

//需求2：在控制台输入三个int值，由小到大输出(xx<xx<xx)
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入第一个数字：");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字：");
		int b = scan.nextInt();
		System.out.println("请输入第三个数字：");
		int c = scan.nextInt();
		
		//最大值
		int max = (a>b)?a:b;
		max = (max>c)?max:c;
		
		//最小值
		int min = (a<b)?a:b;
		min = (min<c)?min:c;
		
		//中间值
		int mid = a+b+c-max-min;
		
		System.out.println(min + "<" + mid + "<" + max);

面试拓展：

//扩展面试题2：
			char x = 'x';//'x' - 字符编码 - 120
			int i = 100;
			System.out.println((false)?i:x);//120
			
		//扩展面试题3：
			char x = 'x';//'x' - 字符编码 - 120
			System.out.println((false)?100:x);//x
			System.out.println((false)?100000:x);//120
			
		返回值规则：
			值1和值2都是常量的情况，按照取值范围大的类型返回数据
			值1和值2都是变量的情况，按照取值范围大的类型返回数据
			值1和值2一个是变量一个是常量的情况，判断常量是否在变量所属类型的取值范围里
				在  -- 按照变量类型返回数据
				不在 - 按照常量类型返回数据

位运算符

符号：

& 与，| 或， ^异或，<< 左移， >> 右移， >>> 无符号右移

理解：将十进制数转化成二进制数进行运算

& 与：同位相比，两者都为1，结果才为1

			byte b1 = 19;//0001,0011
			byte b2 = 25;//0001,1001
						 //0001,0001
			//b1 - byte：0001,0011
			//		int：0000,0000,0000,0000,0000,0000,0001,0011
			//b2 - byte：0001,1001
			//		int：0000,0000,0000,0000,0000,0000,0001,1001
			//	   结果：0000,0000,0000,0000,0000,0000,0001,0001
			//	   byte：0001,0001
			byte result = (byte)(b1 & b2);
			System.out.println(result);//17

| 或：同位相比，两者中一个为1，则结果就为1

			int a = 19;//0000,0000,0000,0000,0000,0000,0001,0011
			int b = 25;//0000,0000,0000,0000,0000,0000,0001,1001
					   //0000,0000,0000,0000,0000,0000,0001,1011
			System.out.println(a | b);//27

^ 异或：同位相比，两者相同为0，不同为1

			int a = 19;//0000,0000,0000,0000,0000,0000,0001,0011
			int b = 25;//0000,0000,0000,0000,0000,0000,0001,1001
					   //0000,0000,0000,0000,0000,0000,0000,1010
			System.out.println(a ^ b);//10

注意：
&、|、^前后两侧都是数值，该符号为位运算符
&、|、^前后两侧都是boolean值，该符号为逻辑运算符

<< 左移：整体向左移动n 位，移动几位就在低位补几个0

注意：左移1位相当于乘以2

			int a = 128;//0000,0000,0000,0000,0000,0000,1000,0000
						//0000,0000,0000,0000,0000,0010,0000,0000
			System.out.println(a << 2); //512

>> 右移：整体向右移动n位，在高位补n个“符号位”

注意：向右移动1位相当于除以2

			int a = 128;//0000,0000,0000,0000,0000,0000,1000,0000
						//0000,0000,0000,0000,0000,0000,0010,0000
			System.out.println(a >> 2);//32

>>> 无符号右移：

注意：无符号右移在处理正数时，与右移操作没有区别

在操作负数时，会在高位补0

			int c = 128;//0000,0000,0000,0000,0000,0000,1000,0000
						0000,0000,0000,0000,0000,0000,0010,0000
			System.out.println(c >>> 2);//32
			
			int d = -128;//1111,1111,1111,1111,1111,1111,1000,0000
						 //0011,1111,1111,1111,1111,1111,1110,0000
			System.out.println(d >>> 2);//1073741792

**面试题：**描述以下代码运行结果

		//考点：char类型向上转型使用0补位，因为char类型取值范围没有负数
			//-1 - int：1111,1111,1111,1111,1111,1111,1111,1111
			//	(byte)：1111,1111
			//  (char)：1111,1111,1111,1111
			//	 (int)：0000,0000,0000,0000,1111,1111,1111,1111
			
			System.out.println((int)(char)(byte)-1);

一向迷人

关注

47
点赞
踩
17

收藏

觉得还不错? 一键收藏
1
评论
Java运算符

或，|| 短路或：前后都接boolean值，只要有其中一个为true，则其结果就是true。& 与，&& 短路与：前后都接boolean值，前后都成立结果才能成立（true）^ 异或：前面都接boolean值，前后的值不同为true，相同为false。值1和值2一个是变量一个是常量的情况，判断常量是否在变量所属类型的取值范围里。& 与，| 或， ^异或，> 右移， >>> 无符号右移。语法格式：变量= (判断表达式)？值1和值2都是变量的情况，按照取值范围大的类型返回数据。
复制链接

扫一扫