JAVA运算符（-算术运算符[+ - * / % ++ --] -赋值运算符[==] -比较运算符 -逻辑运算符 -位运算符(位异或实现变量交换) -三元（三目）运算符）

最新推荐文章于 2024-01-28 07:45:00 发布

Tony-1fan

最新推荐文章于 2024-01-28 07:45:00 发布

阅读量1.3k

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_39497997/article/details/108791949

版权

java 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

一，运算符

1，概述

运算：对常量和变量进行操作的过程就叫做运算
运算符：对常量和变量进行操作时使用的符号就称之为运算符

2，分类

算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
三元（三目）运算符

3，算术运算符

+：正号，加，遇到字符串变成链接符号
-：负号，减
*：乘
/：除
%：取余
++：自增（分前后）
–：自减（分前后）

class Demo1{
	public static void main(String[] args){
		//定义变量
		int i = 5;//把3赋值给了int类型的变量i
		int j = 3;
		
		System.out.println(i+j);
		System.out.println(i-j);
		System.out.println(i*j);
		System.out.println(i/j);//整数相除只能得到整数
		//如果我想要获取小数怎么办？
		//把操作的数据任意一个数据变成浮点数
		System.out.println(i*1.0/j);
		
		//%
		System.out.println(i%j);//获取的是余数
	}
}

注意：
整数相除只能得到整数，如果要获取小数，必须把数据变成浮点数类型
/获取的是除法操作的商， %获取的是除法操作的余数

4，++和--的应用

作用：就是对变量进行自增1或者自减1
单独使用的时候放在前后效果一样
放在操作数的前面或者后面是一样的
参与运算的时候使用，放在前后的效果就不一样了
放在操作数的前面，先自增或者自减，然后才参与运算
放在操作数的后面，先参与运算，然后才自增或者自减

/*
++ 和 --
*/
class Demo2{
	public static void main(String[] args){
		//定义变量
		int i = 5;
		int j = 3;
		//字符串拼接
		//System.out.println("i="+i);
		//System.out.println("j="+j);
		System.out.println("i="+i+",j="+j);
		
		//单独使用
		//i++;
		//j--;
		++i;
		--j;
		System.out.println("i="+i+",j="+j);
		
		//System.out.println(8++); 错误: 意外的类型  常量不能这样用
		System.out.println("------------------------------");
		
		//参与运算
		int a = 3;
		int b = 4;
		
		//int c = a++;
		//int d = b--;
		//System.out.println("a="+a+",b="+b+",c="+c+",d="+d);//a=4,b=3,c=3,d=4
		
		int c = ++a;
		int d = --b;
		System.out.println("a="+a+",b="+b+",c="+c+",d="+d);//a=4,b=3,c=4,d=3
	}
}

-运算符的优先级（看图）在这里插入图片描述

如果我们需要在程序中改变运算顺序，可以使用()

/*
+的3种用法
加法
正号
字符串链接符
*/
class Demo3{
	public static void main(String[] args){
		//加法
		System.out.println(5+6);
		//正号
		System.out.println(+6);
		System.out.println('a'+1);//这里是加运算
		//字符串链接符
		System.out.println("x="+5+",y="+6);
		System.out.println("hello"+"world"+1);
		System.out.println('a'+1+"hello");
	}
}

5，赋值运算符

=
+=
-=
*=
/=
%=

=:基本的赋值运算符，把=右边的数据赋值给左边
其他的都是属于扩展的赋值运算符，把左边和右边做运算，然后把结果赋值给左边

/*
赋值运算符
*/
class Demo4{
	public static void main(String[] args){
		//定义一个变量
		int i = 5;
		//其他用法
		int a,b;
		a = b = 6;
		System.out.println("a="+a+",b="+b);
		System.out.println("------------------------");
		
		//定义一个变量
		int j = 5;
		j += 6;//类似 j = j+6
		System.out.println("j="+j);
		
		//定义一个变量
		int j2 = 5;
		j2 -= 6;
		System.out.println("j2="+j2);
		
		//定义一个变量
		int j3 = 5;
		j3 *= 6;
		System.out.println("j3="+j3);
		
		//定义一个变量
		int j4 = 5;
		j4 /= 6;
		System.out.println("j4="+j4);
		
		//定义一个变量
		int j5 = 5;
		j5 %= 6;
		System.out.println("j5="+j5);
	}
}

class Test3{
	public static void main(String[] args){
		//short s = 1;s = s+1;错误: 不兼容的类型: 从int转换到short可能会有损失
		short s = 1;s += 1;
		//上面2个有没有区别？有没有问题？如果有问题在哪里？
		//第一个会报错，s+1这个1是默认是int类型，s是short类型，在运算的时候
		//会先转成int类型，然后运算完的结果是int类型，赋值又付给了s的short类型，所以报错
		//第二个不会报错，扩展的运算符实际上隐含了一个  强制类型转换
		//s+=1  不等价于  s=s+1  实际上等价于 s = (s的数据类型)(s+1)
	}
}

-注意：扩展的运算符实际上隐含了一个强制类型转换

6，比较运算符（关系运算符）

==
!=
<
>
<=
>=
instanceof 判断是否是类的对象
-注意：比较运算符的结果都是boolean类型的结果，意思就是最终的结果要么是true要么是false

class Demo5{
	public static void main(String[] args){
		int x = 4;
		int y = 5;
		int z = 4;
		
		System.out.println(x == y);
		System.out.println(x == z);
		//不论我们的操作简单还是复杂，结果都是boolean类型
		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);
		
		
		int a = 5;
		int b = 6;
		
		boolean boo = (a==b);//==不要写称=
		System.out.println(boo);
		
		int c = (a = b);
	}
}

7，逻辑运算符

& 与 and
| 或 or
^ 异或
! 非 not
&& and 双与（短路）
|| or 双或（短路）
逻辑运算符用来链接布尔类型表达式的符号
0<age<150 这个年领合法但是在java中不能直接这样写
应该是这样 age>0 & age<150
特点：
一般是用来链接boolean类型的表达式或者值
表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子
a+b 算术表达式
a==b 比较表达式
…

/*
结论：
	&：逻辑与   有false则false 
	|: 逻辑或   有true则true
	^: 逻辑异或  相同为false，不同为true
		举例：情侣关系  男和女，女和男都是真  两女或者两男都不合适
	!: 逻辑非  非false则true，非true则false
		特点：偶数个本身不变，奇数个取反
	&&：逻辑双与   有false则false 
	||: 逻辑双或   有true则true
*/
class Demo6{
	public static void main(String[] args){
		//定义变量
		int a = 4;
		int b = 5;
		int c = 6;
		
		//& 逻辑与
		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
		System.out.println("--------------------------");
		
		//&& 逻辑双与
		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("--------------------------");

	}
}

&和&&，|和||的区别

/*
&和&&，|和||的区别
结论:
	最终结果是一样的
	&左边无论真假，右边都会执行（都会进行运算）
	&&具有短路效果，当左边是真的时候，右边会执行
		当左边是false的时候，右边不执行
	
	|左边无论真假，右边都会执行（都会进行运算）
	||具有短路效果，当左边是真的时候，右边不会执行
		当左边是false的时候，右边执行
		
	一般建议用&&  和  ||
		
-异或和|的不同：当左右都为true时，结果是false
*/
class Demo7{
	public static void main(String[] args){
		/*
		//定义变量
		int a = 4;
		int b = 5;
		int c = 6;
		
		//&& 逻辑双与
		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("--------------------------");
		*/
		int x = 3;
		int y = 4;
		
		//boolean boo = (x++ == 3) & (y++ == 4);//true & true = true
		//System.out.println("x="+x+",y="+y);//x=4,y=5
		//System.out.println(boo);//true
		
		
		//boolean boo = (x++ == 3) && (y++ == 4);//true & true = true
		//System.out.println("x="+x+",y="+y);//x=4,y=5
		//System.out.println(boo);//true
	
		//boolean boo = (++x == 3) & (y++ == 4);//false & true = false
		//System.out.println("x="+x+",y="+y);//x=4,y=5
		//System.out.println(boo);//false
		
		boolean boo = (++x == 3) && (y++ == 4);//false & true = false
		System.out.println("x="+x+",y="+y);//x=4,y=4
		System.out.println(boo);//false
		
	}
}

8，位运算符

<< 左移
>> 右移
>>> 无符号右移
& 位与运算符
| 位或运算符
^ 位异或
~ 反码（取反）

**位运算符是直接对二进制数据进行运算的，所以我们要做位运算，就要先把数据转换成二进制数据

/*
分析：
	首先是位运算，所以我们需要先把数据转成二进制形式
	3的二进制  00000000 00000000 00000000 00000011
	4的二进制  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
*/
class Demo1{
	public static void main(String[] args){
		//&  |  ^  ~
		int a = 3;
		int b = 4;
		/*
		System.out.println(3&4);//0
		System.out.println(3|4);//7
		System.out.println(3^4);//7
		System.out.println(~3);//-4
		*/
		System.out.println(a&b);//0
		System.out.println(a|b);//7
		System.out.println(a^b);//7
		System.out.println(~a);//-4
	}
}

/*
^位异或特点：
	一个数据对另一个数据位异或2次，该数本身不变
	
要求大家自己把这个和Demo1一样自己推一遍
*/
class Demo2{
	public static void main(String[] args){
		int a = 5;
		int b = 6;
		System.out.println(a^b^b);//5
		System.out.println(a^b^a);//6
	}
}

//实现2个整数变量的交换
class Test1{
	public static void main(String[] args){
		int a = 5;
		int b = 6;
		System.out.println("a="+a+",b="+b);
		
		//方式一  使用第三方变量 （开发）
		//int c = a;
		//a = b;
		//b = c;
		//System.out.println("a="+a+",b="+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);
		
		//方式三  用变量相加
		//a = a+b;//11
		//b = a-b;//5
		//a = a-b;//6
		//System.out.println("a="+a+",b="+b);
		
		//方式四
		b = (a+b)-(a=b);
		System.out.println("a="+a+",b="+b);
	}
}

/*
<<  左移  左边最高位丢弃，右边补0
>>  右移  最高位是0，左边补0，最高位是1，左边补1
>>> 无符号右移   无论最高位是0还是1  左边补0
*/
class Demo3{
	public static void main(String[] args){
		//<<结论  把<<左边的数据乘以2的移动次幂
		System.out.println(1<<2);//4   1*2^2 = 4
		System.out.println(3<<2);//12  3*2^2 = 3*4 = 12
		System.out.println(12<<2);//48  12*2^2 = 12*4 = 48
		
		//>>结论  把>> 左边的数据除以2的移动次幂
		System.out.println(3>>2);//0    3/2^2 = 3/4  = 0
		System.out.println(12>>2);//3   12/2^2 = 3
		System.out.println(24>>2);//24/2^2 = 24/4 = 6
		System.out.println(-24>>2);// -24/2^2 = -24/4 = -6
		
		System.out.println(24>>>2);//6
		System.out.println(-24>>>2);//1073741818   
		
		/*
		计算24的二进制   11000
		原码：10000000 00000000 00000000 00011000
		反码：11111111 11111111 11111111 11100111
		补码：(00)11111111 11111111 11111111 111010(00)
		>>>2 
		-------------------------------------------
		补码： 0011111111 11111111 11111111 111010（原码）
		
		*/
	}
}

/*
如何用最有效率的方式计算2个整数相乘的结果？
*/
class Test2{
	public static void main(String[] args){
		int a = 2;
		int b = 8;
		//a*b   2*8
		//a<<3
	}
}

9，三元（三目）运算符

格式：关系（比较）表达式 ? 表达式一:表达式二;
比较表达式结果是一个boolean类型
解释：如果关系表达式结果是真，运算之后的结果为表达式一的结果
如果关系表达式结果是假，运算之后的结果为表达式二的结果

class Demo4{
	public static void main(String[] args){
		int a = 8;
		int b = 6;
		int z = (a>b)?a:b;
		System.out.println(z);
	}
}

class Demo5{
	public static void main(String[] args){
		int a = 8;
		int b = 6;
		int c = 55;
		//获取3个数中最大的值
		//思路：
			//可以分2步
			//先比较a和b的值，拿到较大的
			//在拿a和b中较大的和C比较
		//int temp = a>b?a:b;
		/*
		int temp = (a>b)?a:b;
		System.out.println(temp);
		int max = temp>c?temp:c;
		System.out.println("max="+max);
		*/
		
		//int max = (a>b)?(a>c?a:c):(b>c?b:c);
		int max = a>b?a>c?a:c:b>c?b:c;
		System.out.println("max="+max);
		System.out.println("-----------------------------");
		//比较2个数是否相等
		
		int x = 55;
		int y = 66;
		//boolean boo = ((x==y)?true:false);
		boolean boo = (x==y);
		System.out.println(boo);
	}
}

Tony-1fan

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JAVA运算符（-算术运算符[+ - * / % ++ --] -赋值运算符[==] -比较运算符 -逻辑运算符 -位运算符(位异或实现变量交换) -三元（三目）运算符）

一，运算符1，概述运算：对常量和变量进行操作的过程就叫做运算运算符：对常量和变量进行操作时使用的符号就称之为运算符2，分类算术运算符赋值运算符比较运算符逻辑运算符位运算符三元（三目）运算符3，算术运算符+：正号，加，遇到字符串变成链接符号-：负号，减*：乘/：除%：取余++：自增（分前后）–：自减（分前后）class Demo1{ public static void main(String[] args){ //定义变量 int i = 5;//把3赋值给了
复制链接

扫一扫

专栏目录