小白自学笔记——JAVA基础 2.6运算符

最新推荐文章于 2024-08-15 14:47:41 发布

成长中的韭皇

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量180

点赞数 1

分类专栏： JAVA基础文章标签： java

本文链接：https://blog.csdn.net/weixin_46304886/article/details/120564734

版权

JAVA基础专栏收录该内容

22 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的各种运算符，包括算术运算符、赋值运算符、比较运算符、逻辑运算符和位运算符，并通过实例展示了它们的用法。此外，还提到了三元运算符的使用和运算符的优先级。文章最后讨论了如何交换两个变量的值，并给出了相关练习的解答。

摘要由CSDN通过智能技术生成

名词解释

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
- 算术运算符
- 赋值运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- *位运算符
- 三元运算符

算术运算符

在这里插入图片描述
eg：

class AriTest{
	public static void main(String[] args){
		//除号：
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);//2
		int result2 = num1 / num2 * num2;
		System.out.println(result2);//10
		double result3 = num1 / num2;
		System.out.println(result3);//num1 / num2先运算的结果已经是2。只是把2赋值给result3.
		double result4 = num1 / num2 + 0.0;//2.0。先算除得2，然后算加得2.0。
		double result5 = num1 / (num2 + 0.0);//2.4。先算括号内的加，转换为double类得2.0；然后算除，转换为double类，得2.4。
		double result6 = (double)num1 / num2;//2.4。先算num1转换double型，得12.0；然后算除，得2.4 。
		double result7 = (double)(num1 / num2);//2.0。先运算括号内的int型除，得2；然后转换为double型，得2.0。
		System.out.println(result4);
		System.out.println(result5);
		System.out.println(result6);
		System.out.println(result7);

		//%:取模（余）运算
		//结果与被模数的符号有关。
		//开发中，经常使用%来判断能否被除尽。
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 =" + m1 % n1);
		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 =" + m2 % n2);
		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 =" + m3 % n3);
		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 =" + m4 % n4);
		
		//前++：先自增1，然后运算。
		//后++：先运算，然后自增1。
		//变量自增1 。
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 =" + a1 +",b1 =" + b1);//a1=11,b1=11
		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 =" + a2 +",b2 =" + b2);//a2=11,b2=10
		int a3 = 10;
		a3++;//a3先自增1。++a3也一样。
		int b3 = a3;
		System.out.println("a3 =" + a3 +",b3 =" + b3);//a3=11,b2=10
		
		//注意点
		short s1 = 10;
		//s1 = (short)(s1 + 1);=s1++
		s1++;//自增1不会改变本身数据类型。
		System.out.println(s1);

		byte bb1 = 127;
		bb1++;
		System.out.println(bb1);//-128

		//前--：先自减1，后运算。
		//后--：先运算，后自减1。
		int a4 = 10;
		int b4 = a4--;
		System.out.println("a4 =" + a4 +",b4 =" + b4);//a3=11,b2=10
	}
}

练习
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1

class  AriExer{
	public static void main(String[] args) {
		int num = 187;
		int ge = num % 10;
		int shi = (num / 10 ) % 10;
		int bai = num / 100;
		System.out.println("数字187的情况如下：");
		System.out.println("个位数：" + ge);
		System.out.println("十位数：" + shi);
		System.out.println("百位数：" + bai);
	}
}

赋值运算符

符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。
扩展赋值运算符： +=, -=, *=, /=, %=
eg:

class SetValueTest {
	public static void main(String[] args) {
		//赋值符号：=
		int i1 = 10;
		int j1 = 10;
		//连续赋值
		int i2,j2;
		i2 = j2 = 10;
		int i3 = 10,j3 = 20;
		//*************************
		int num1 = 10;
		num1 += 2;//num1 = num1 + 2
		System.out.println(num1);
		
		int num2 = 12;
		num2 %= 5;//num2 = num2 % 5
		System.out.println(num2);

		short s1 = 10;
		//s1 = s1 + 2;编译失败
		s1 += 2;
		System.out.println(s1);//不改变变量本身数据类型。
	
		//开发中希望变量实现+2的操作，有几种方法？（前提：int num = 10;)
		//方式一：num = num + 2;
		//方式二：num += 2;(更优）
		//开发中希望变量实现+1的操作，有几种方法？（前提：int num = 10;)
		//方式一：num = num + 1;
		//方式二：num += 1;
		//方式三：num++;(推荐）
	}
}

练习：
在这里插入图片描述
思考1：1编译错误。2可行。
思考2：

int i = 1;
i *= 0.1;//不改变变量类型，所以i=0。
System.out.println(i);
i++;//i=1
System.out.println(i);

思考3：

int m = 2;
int n = 3;
n *= m++;//前++，所以先运算再自增1。m=3,n=6。
System.out.println("m=" + m);
System.out.println("n=" + n);

思考4：

int a = 10;
a += (a++) + (++a);
//相当于a = a + (a++) + (++a)
//相当于a = 10 + 10(先运算后自增) + 12(第二项a++使a值为11，第三项在11上在自增1。)
System.out.println(a);//32

拓展思考4：

int a1,a2,a3,a4,a5;
a1 = a2 = a3 = a4 = a5 = 10;
a1 += a1++;//a1 = a1 + a1++ ——> a1 = 10 + 10
System.out.println("a1=" + a1);//20
a2 += ++a2;//a2 = a2 + ++a2 ——> a2 = 10 + 11
System.out.println("a2=" + a2);//21
a3 += (a3++ + ++a3);//a3 = a3 + (a3++ + ++a3) ——> a3 = 10 + (10 + 12)
System.out.println("a3=" + a3);//32
a4 = a4++ + a4;// a4 = 10 + 11
System.out.println("a4=" + a4);//21
a5 = ++a5 + a5;// a5 = 11 + 11
System.out.println("a5=" + a5);//22
//注意这样编译是错的
//a5 = ++(a5++);

比较运算符

在这里插入图片描述
比较运算符的结果都是boolean型，也就是要么是true，要么是false。

class CompareTest{
	public static void main(String[] args){
		int i = 10;
		int j = 20;
		System.out.println(i == j);//false
		System.out.println(i = j);//先将j赋值给i，再输出i。
		
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true
	}
}

逻辑运算符

在这里插入图片描述
与：a、b都为true，结果才是true。
或：a、b中有一个为true，结果就是true。
非：取反。a为true，!a为false。
异或：a、b相同为true；反之为false。

逻辑运算符操作的都是布尔类型的变量。

eg:

class LogicTest {
	public static void main(String[] args) {
		//区分& 与 &&;
		//相同点1：&与&& 运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算。
		//不同点：当符号左边为false时，&继续执行符号右边运算，&&不在执行符号右边运算。
		//开发中推荐使用&&。
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num1 =" + num1);

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num2 =" + num2);
	
		//区分： |与||
		//相同点1：|与|| 运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算。
		//不同点：当符号左边为true时，|继续执行符号右边运算，||不在执行符号右边运算。
		//开发中推荐使用||。
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 =" + num3);

		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 =" + num4);
	}
}

判断练习：
[1]
int x = 1;
int y=1;
if(x++2 & ++y2){
x =7;
}
System.out.println(“x=”+x+",y="+y);

[2]
int x = 1,y = 1;
if(x++2 && ++y2){
x =7;
}
System.out.println(“x=”+x+",y="+y);

[3]
int x = 1,y = 1;
if(x++ == 1 | ++y ==1){
x =7;
}
System.out.println(“x=”+x+",y="+y);

[4]
int x = 1,y = 1;
if(x++ == 1 || ++y==1){
x =7;
}
System.out.println(“x=”+x+",y="+y);

[5]
class Test {
public static void main (String [] args) {
boolean x=true;
boolean y=false;
short z=42;
//if(y == true)
if((z++42)&&(y=true))z++;
if((x=false) || (++z45)) z++;
System. out.println(“z=”+z);
}
}

答案
1.x=2,y=2
2.x=2,y=1
3.x=7,y=2
4.x=7,y=1
5.z=46

位运算符

在这里插入图片描述

注意：位运算符操作的都是整型的数据，是直接对二进制进行的运算。逻辑运算符是对布尔型操作。

左移、右移

在这里插入图片描述

<<:在一定范围内，每向左移1位，相当于*2（也适用于负数）。
>>:在一定范围内，每向右移1位，相当于/2（也适用于负数）。

eg:最高效的方式计算2*8？
2 << 3 或 8 << 2

eg左移、右移：

class BitTest {
	public static void main(String[] args) {
		int i = 21;
		System.out.println("i << 2 :" + (i << 2));//84
		System.out.println("i << 27:" + (i << 26));//1409286144
		System.out.println("i << 27:" + (i << 27));//-1476395008。最高位（符号位）是1。
		int j = -21;
		System.out.println("j << 2 :" + (j << 2));//-84
		System.out.println("j >> 27:" + (j >> 2));//-6
	}
}

与、或、异或、取反

在这里插入图片描述

计算时，可以把 0 看做 false，1看做 true。

小技巧
如上图可以发现：m = ( m ^ n ) ^ n ; n = ( m ^ n ) ^ m。

eg：

class BitTest {
	public static void main(String[] args) {
		int i = 21;
		System.out.println("i << 2 :" + (i << 2));//84
		System.out.println("i << 27:" + (i << 26));//1409286144
		System.out.println("i << 27:" + (i << 27));//-1476395008。最高位（符号位）是1。
		int j = -21;
		System.out.println("j << 2 :" + (j << 2));//-84
		System.out.println("j >> 27:" + (j >> 2));//-6
		
		int m = 12;
		int	n = 5;
		System.out.println("m & n:" + (m & n));//4
		System.out.println("m | n:" + (m | n));//13
		System.out.println("m ^ n:" + (m ^ n));//9

		//练习:交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1=:" + num1 +",num2=" + num2);
		
		//方式一：定义临时变量
		//推荐方式。
		//int temp = num1;
		//num1 = num2;
		//num2 = temp;

		//方式二：
		//好处：不用定义临时变量
		//弊端：1.相加可能超出存储范围。2.有局限性：只限数值型。
		//num1 = num1 + num2;
		//num2 = num1 - num2;
		//num1 = num1 - num2;
		
		//方式三：使用位运算符
		//有局限性：只限数值型。
		//num1 = num1 ^ num2;
		//num2 = num1 ^ num2;
		//num1 = num1 ^ num2;
		System.out.println("num1=:" + num1 +",num2=" + num2);
	}
}

三元运算符

在这里插入图片描述
说明：

条件表达式的结果为boolean类型。
根据条件表达式真或假，决定执行表达式1，还是表达式2。
- 如果表达式为true，则执行表达式1.
- 如果表达式为false，则执行表达式2.
表达式1和表达式2要求是一致的。
三元运算符可以嵌套使用。
凡是可以使用三元运算符的地方，都可以改写为if-else。反之不成立。
如果程序既可以使用三元运算符，又可以使用if-else，优先选择三元。因为三元简介效率高。

eg:

class  SanYuanTest{
	public static void main(String[] args) {
		//获取两个整数的较大值
		int m = 12;
		int n = 5;
		
		int max = (m > n)? m : n;
		System.out.println(max);

		double num = (m > n)? 2:1.0;
		System.out.println(num);
		
		//int num2 = (m > n)? 2 : "n大"; 编译错误：表达式1和表达式2不一致
		//System.out.println(num2);

		//****************
		//嵌套使用
		n = 12;
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);

		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;

		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		//int max2 = (n1 > n2)? ((n1 > n3)? n1 : n3) : ((n2 > n3)? n2 : n3);
		//int max2 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中的最大值为：" + max2);
		//改写成if-else
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

运算符优先级运算符有不同的优先级，所谓

优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行。
只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

本章完结！

成长中的韭皇

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
小白自学笔记——JAVA基础 2.6运算符

名词解释运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。- 算术运算符- 赋值运算符- 比较运算符（关系运算符）- 逻辑运算符- *位运算符- 三元运算符算术运算符eg：class AriTest{ public static void main(String[] args){ //除号： int num1 = 12; int num2 = 5; int result1 = num1 / num2; System.out.println(result
复制链接

扫一扫

专栏目录