java基础——运算符

于 2024-05-17 21:14:57 发布
阅读量563 收藏 13
点赞数 24
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77967541/article/details/138870559
版权

预算符简介

运算符是一种特殊的符号，用以表示数据的运算、赋值、比较等。

包含：算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符、三元运算符。

算术预算符

+正号，表示数值为正数
-负号，表示数值为负号
+加号，将数值相加求和
-减号，将数值相减求差
*乘号，将数值相乘
/除号，将数值相除
%取余（取模）
++

自增符号

--自减符号
+字符串相加

在我们的算术运算符当中+、-、*与数学当中无异，我们重点来看一下/、%、++、--。

/（除号）

        //我们直接使10除以4，这里我们的10和4是int类型
		System.out.println(10/4);
		//这里我们的10.0是double类型
		System.out.println(10.0/4);
		//这里我们把结果变成double类型
		double num = 10 / 4;
		System.out.println(num);
2
2.5
2.0

这里我们可以看到，当我们直接拿10除以4得到的结果是2，但是我们在现实生活中得出来的应该是2.5，为什么不同呢，那就是因为我们的10和4为int类型，得出的结果便是int类型，所以只能得出2，我们将10.0除以4就可以的出我们想要的结果，因为这里的10.0是double类型，精度更高。

%（取模、取余）

取模（取余）顾名思义，那就是去余数。

        System.out.println(10%3);
		
		System.out.println(-10%3);
		
		System.out.println(10%-3);
		
		System.out.println(-10%-3);
1
-1
1
-1

我们来看，我们都知道10除以3是商3余1，自然余数为1，那么如果参与到负数我们该怎么办呢，其实很容易，我们有一套公式：a%b  ->  a - a / b * b；就是这样一个公式，我们的问题就迎刃而解。

++（自增符号） (++i、i++)

首先当作为独立语句使用；前置++与后置++都是完全等价于 i = i + 1;

当作为表达式使用时：前置++： ++i 先自增后赋值

                                     后置++： i++ 先赋值后自增

        int num1 = 4;
		//前置++，先自增后赋值
		int num2 = ++num1;// num1 = num1 + 1;num2 = num1;
		System.out.println("num1="+num1+"\t"+"num2="+num2);
		
		int num3 = 4;
		//后置++，先赋值，后自增
		int num4 = num3++;// num4 = num3; num3 = num3 + 1;
		System.out.println("num3="+num3+"\t"+"num4="+num4);
num1=5	num2=5
num3=5	num4=4

--（自减符号）(--i、i--)

首先当作为独立语句使用；前置--与后置--都是完全等价于 i = i - 1;

当作为表达式使用时：前置--： --i 先自减后赋值

                                     后置--： i-- 先赋值后自减

        int num1 = 4;
		//前置--，先自减后赋值
		int num2 = --num1;// num1 = num1 - 1;num2 = num1;
		System.out.println("num1="+num1+"\t"+"num2="+num2);
		
		int num3 = 4;
		//后置--，先赋值后自减
		int num4 = num3--;// num4 = num3; num3 = num3 - 1;
		System.out.println("num3="+num3+"\t"+"num4="+num4);
num1=3	num2=3
num3=3	num4=4

到这里我们来看一个例题：

        int i = 2;
		//后置++
		i = i++;//这里大概是使用了一个临时变量:temp = i; i = i + 1; i = temp;
		System.out.println(i);
		
		int j = 2;
		//前置++
		j = ++j;//使用临时变量： j = j + 1; temp = j; j = temp;
		System.out.println(j);
2
3

--与++同理。

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

booleantrue 或 false
==判断相等
！=判断不等
<小于
>大于

<=

小于等于
>=大于等于
instanceof检查是否为类的对象
        int s = 5;
		int z = 7;
		
		System.out.println(s == z);//false
		System.out.println(s != z);//true
		System.out.println(s > z);//false
		System.out.println(s < z);//true
		System.out.println(s >= z);//false
		System.out.println(s <= z);//true
false
true
false
true
false
true

注意：

1.关系运算符的结果都为boolean型，也就是要么是true，要么是false。

2.关系运算符组成的表达式，我们称之为关系表达式。

3.比较运算符“ == ”不能写成“ = ”。

逻辑运算符

&逻辑与
&&短路与
|逻辑或
||短路或
！取反
^逻辑异或

运算规则：

1. a & b 时，&叫逻辑与，规则：当a和b同时为true，则结果为true，否则结果为false。

2. a && b 时，&&叫短路与，规则：当a和b同时为true，则结果为true，否则结果为false。

3.  a | b 时，|叫逻辑或，规则：当a和b当中有一个为true时，结果即为true，两者都为false，结果才为false。

4. a || b 时，||叫短路或，规则：当a和b当中有一个为true时，结果即为true，两者都为false，结果才为false。

5.！a时，！叫取反，规则：当a为true，则结果为false，。当a为false时，结果为true。

6.a ^ b时，^叫逻辑异或，规则：当a和b不同时，结果为true，否者为false。

a

ba&b（逻辑与）a&&b（短路与）a|b（逻辑或）a||b（短路或）！a（取反）a^b（逻辑异或）
TTTTTTFF
FTFFTTTT
TFFFTTFT
FFFFFFTF

(TRUE（真）简写为T，FALSE（假）简写为F)

那么我们通过上述结果判断，逻辑与和短路与、逻辑或与短路或有什么区别吗？

短路与和逻辑与

        int s = 5;
		int z = 7;
		
		//短路与
		if(s < 2 && ++z < 50) {
			System.out.println("判断正确");
		}
		System.out.println("s="+s+"\t"+"z="+z);
		
		//逻辑与
		if(s < 2 & ++z < 50) {
			System.out.println("判断正确");
		}
		System.out.println("s="+s+"\t"+"z="+z);
s=5	z=7
s=5	z=8

通过程序我们可以看到我们的变量z发生了变化。因此我们可以得到

短路与：&&——> 如果第一个条件为假（false）时，后面的判断语句就不会执行。

逻辑与：&——> 如果第一个条件为假（false）时，后面的判断语句依旧会执行。

短路或和逻辑或

        int r = 2;
		int p = 7;
		//短路或
		if(r > 1 || ++p <50) {
			System.out.println("判断正确");
		}
		System.out.println("r="+r+"\t"+"p="+p);
		//逻辑或
		if(r > 1 | ++p <50) {
			System.out.println("判断正确");
		}
		System.out.println("r="+r+"\t"+"p="+p);
判断正确
r=2	p=7
判断正确
r=2	p=8

通过程序我们可以看到我们的变量p发生了变化。因此我们可以得到

短路或：||——> 如果第一个条件为真（true）时，后面的判断语句就不会执行。

逻辑或：|——> 如果第一个条件为真（true）时，后面的判断语句依旧会执行。

取反

        System.out.println(10>3);//true
		System.out.println(!(10>3));//!(true)->false
true
false

取反！：当结果为真取反之后结果为假，如果结果为假，取反结果为真。

逻辑异或

        //逻辑异或
		boolean p1 = (10 > 1) ^ (3 > 1);
		System.out.println("p1="+p1);
		
		boolean p2 = (10 > 1) ^ (3 < 1);
		System.out.println("p2="+p2);
p1=false
p2=true

逻辑异或^：当两个判断结果为不同时，总体的结果才为真（true），如果相同则为假（false）。

赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。

赋值运算符分类： +=、-=、/=、%=等。

例如：

        int n1 =4;
		n1 += 4;// n1 = n1 + 4;
		System.out.println(n1);
		
		int n2 = 4;
		n2 -= 2;//n2 = n2 - 2;
		System.out.println(n2);
		
		int n3 = 4;
		n3 /= 2;//n3 = n3 / 2;
		System.out.println(n3);
		
		int n4 = 4;
		n4 *= 2;//n4 = n4 * 2;
		System.out.println(n4);
		
		int n5 = 5;
		n5 %= 2;//n5 = n5 % 2;
		System.out.println(n5);
8
2
2
8
1

注意：

1.运算顺序从右向左。

2.赋值运算符的左边，只能是变量，右边可以是变量、表达式、常量值。

        int num1 = 20;
		int num2 = 54*62-10;
		int num3 = 'a';
		System.out.println(num1);
		System.out.println(num2);
		System.out.println(num3);
20
3338
97

3.复合赋值运算符会进行类型转换。

        byte b = 2;
		b += 3;//b = b + 3;b是byte类型的，而3是int类型，所以 b = (byte)( b + 3 )
		b++;//b = b + 1;同理 b = (byte)( b + 1 );
		System.out.println(b);
6

位运算符（需要二进制进行）

在Java中有7个位运算（&、|、^、~、>>、<<、>>>）

按位与&：两位全为1，结果为1，否则为0；

按位或|：两位有一个1，结果就为1，否则为0；

按位异或^：两位一个为1一个为0，结果为1，其他的为0；

按位取反~ ：如果是0就变成1，如果是1就变成0；

例如：

        int c1 = 2&3;
		//2的二进制原、反、补码都相同：00000000 00000000 00000000 00000010（2）
		//3的二进制原、反、补码都相同：00000000 00000000 00000000 00000011（3）
		//按位与，全为1，结果为1，反之为0；
		//2&3 ： 00000000 00000000 00000000 00000010（2）
		System.out.println(c1);
		
		int c2 =2|3;
		//2的二进制原、反、补码都相同：00000000 00000000 00000000 00000010（2）
		//3的二进制原、反、补码都相同：00000000 00000000 00000000 00000011（3）
		//按位或，两个有一个1，结果就为1，反之为0；
		//2|3 ： 00000000 00000000 00000000 00000011（3）
		System.out.println(c2);
		
		int c3 = ~-2;
		//-2的二进制的原码：10000000 00000000 00000000 00000010（-2）
		//-2的二进制的反码：11111111 11111111 11111111 11111101(原码按位取反得反码)
		//-2的二进制的补码：11111111 11111111 11111111 11111110（反码+1）
		//按位取反：00000000 00000000 00000000 00000001（1）
		System.out.println(c3);
		
		int c4 = 2 ^ 3;
		//2的二进制原、反、补码都相同：00000000 00000000 00000000 00000010（2）
	    //3的二进制原、反、补码都相同：00000000 00000000 00000000 00000011（3）
		//按位异或：一个为1，一个为0，结果为1，其余为0；
		//2^3: 00000000 00000000 00000000 00000001(1)
		System.out.println(c4);
2
3
1
1

算术右移>> ：低位溢出，符号位不变，并用符号位补溢出的高位

算术左移<<：符号位不变，低位补0

无符号右移>>>：低位溢出，高位补0

特别说明：没有<<< 符号（不存在）

        int c5 = 1 >> 2;
		//1的二进制原、反、补码都相同：00000000 00000000 00000000 00000001（1）
		//算数右移>>:低位溢出，符号位不变，并用符号位补溢出的高位
		//1>>2: 00000000 00000000 00000000 00000000(0)
		System.out.println(c5);		
		
		
		int c6 = 1 << 2;
		//1的二进制原、反、补码都相同：00000000 00000000 00000000 00000001（1）
		//算术左移<<:符号位不变，低位补0
		//1<<2: 00000000 00000000 00000000 00000100(4)
		System.out.println(c6);
0
4

三元运算符

基本语法：条件表达式 ？表达式1 ： 表达式2；

1.如果条件表达式的结果为true，则运算的结果为表达式1；

2.如果条件表达式的结果为false，则运算的结果为表达式2；

        int a1 = 9;
		int a2 = 5;
		int maxnum = a1>a2 ? a1 : a2;
		System.out.println(maxnum);
9

注意：

1.表达式1和表达式2要为可以赋值给接收变量的类型（或者可以自动类型转换）。

2.三元运算符可以转成if-----else语句；

        int a1 = 9;
		int a2 = 5;
		int maxnum = a1>a2 ? a1 : a2;
		System.out.println(maxnum);
		
		if(a1 > a2) {
			System.out.println(a1);
		}else {
			System.out.println(a2);
		}
9
9

如有错误，还望指正。

cheer on seventeen
关注
  • 24
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值