java的运算符-算术、关系、逻辑、位、三目.....

最新推荐文章于 2024-05-18 10:33:53 发布

李科码农

最新推荐文章于 2024-05-18 10:33:53 发布

阅读量189

点赞数 1

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

本文链接：https://blog.csdn.net/like1231/article/details/119080789

版权

java基础专栏收录该内容

28 篇文章 1 订阅

订阅专栏

一、运算符

1、算数运算符：

+、-、*、/、%、++、–

public class Test01{
	
	public static void main(String[] args){
		/**
			知识点：算数运算符的基本使用
			
			+、-、*、/、%、++、--
			
			int num1 = 10;
			int num2 = 5;
			int result = num1 + num2;
			System.out.println(result);//15
			System.out.println(num1 - num2);//5
			System.out.println(10 * 5);//50
			System.out.println(10 / 5);//2
			System.out.println(10 % 3);//1
			
			//++：自增1
			//++a：先自增1，再使用
			int a = 10;
			System.out.println(++a);//11
			System.out.println(a);//11
			
			//b++：先使用，在自增1
			int b = 10;
			System.out.println(b++);//10
			System.out.println(b);//11
			
			//--:自减1
			//--c：先自减1，再使用
			int c = 10;
			System.out.println(--c);//9
			System.out.println(c);//9
			
			//d--：先使用，在自减1
		*/
			int d = 10;
			System.out.println(d--);//10
			System.out.println(d);//9
		
	
	}
}

1.2 金典案例：深入算数运算符

public class Test02{
	
	public static void main(String[] args){
		/**
			知识点：深入算数运算符
			
			+、-、*、/、%、++、--
			
			案例一：byte类型做运算，会向上转型成int
			byte b1 = 10;
			byte b2 = 20;
			//10 - byte - 8位:0000,1010
			//10 - int  -32位:0000,0000,0000,0000,0000,0000,0000,1010
			//20 - byte - 8位:0001,0100
			//20 - int  -32位:0000,0000,0000,0000,0000,0000,0001,0100
			//30 - int  -32位:0000,0000,0000,0000,0000,0000,0001,1110
			//30 - byte - 8位:0001,1110
			byte result = (byte)(b1+b2);
			System.out.println(result);
			
			案例二：short类型做运算，会向上转型成int
			short s1 = 10;
			short s2 = 20;
			short result = (short)(s1+s2);
			System.out.println(result);
			
			案例三：描述下列计算结果的类型
			byte b = 10;
			short s = 10;
			int i = 10;
			long l = 10;
			float f = 1.1F;
			double d = 2.2;
			System.out.println(b+s);//int类型
			System.out.println(i+s);//int类型
			System.out.println(l+s);//long类型
			System.out.println(i+l);//long类型
			System.out.println(i+f);//float类型
			System.out.println(i+d);//double类型
			
			案例四：浮点类型不能直接做运算，要做运算会使用BigDecimal
			double d1 = 0.5;
			double d2 = 0.4;
			System.out.println(d1-d2);//0.09999999999999998
			
			案例5：'a'的ASCII是97
			char c = 'a';
			System.out.println(c+1);//98
		
			经典面试题一：输出结果为？
			int a = 8;
			int b = (a++)+(++a)+(a*10);
			System.out.println(b);//118
			//a = 10
			//b = 8 + 10 + 10
			
			经典面试题二：输出结果为？
			int i =  0;   
			i = ++i; 
			//底层原理：
			//i = (int)(i+1);
			//i = i;
			System.out.println(i);//1
			
			int i = 0;   
			i = i++;  
			//底层原理：
			//int temp = i;--temp用于记录i最初的值
			//i = (int)(i+1);
			//i = temp
			System.out.println(i);//0 
			
			扩展1：
			byte b = 10;
			++b;//底层：b = (byte)(b+1);
			short s = 10;
			++s;//底层：s = (short)(s+1);
			int i = 10;
			++i;//底层：i = (int)(i+1);
			long l = 10;
			l++;//底层：l = (long)(l+1);
			
			扩展2：
		*/
			int i = 10;
			//++i; 和 i++; 没有区别，因为分号是一条执行语句的结束，不管先加还是后加都给我加
			//++i;
			//i++;
			System.out.println(i);
		

	}
}

2、赋值运算符：

=、+=、-=、 *=、/= 、 %=

public class Test03{
	
	public static void main(String[] args){
		/**
			知识点：赋值运算符
			
			=、+=、-=、*=、/=、%=
			
			int i = 10;
		
			i += 10;//i = (int)(i+10);
			i -= 10;//i = (int)(i-10);
			i *= 5 ;//i = (int)(i*5);
			i /= 5 ;//i = (int)(i/5);
			i %= 3 ;//i = (int)(i%3);
			System.out.println(i);//1
			
			经典面试题一：输出结果为？
			//一次性声明多个变量
			int a,b; 
			a = b = 100;//把100赋值给b，b再赋值给a
			System.out.println(a);//100
			System.out.println(b);//100
				
			经典面试题二：下面的两种写法结果分别是？
			short s=1; 
			s = s+1;//报错：short类型的变量s 与 int类型的数字字面量1 做运算的结果是int类型 
		*/
			short s=1; 
			s += 1;//s = (short)(s+1);
			System.out.println(b);
        /**
			赋值规则：
					 s  + = 1			 s  = (T)((s) + (1) )
			复合赋值 E1 op= E2等价于简单赋值 E1 = (T)((E1)op(E2))，
			其中T是E1的类型。
		*/
	
	}
}

3、关系运算符：

==、！=、>、 <、 >=、 <=

public class Test04{
	
	public static void main(String[] args){
		/**
			知识点：关系运算符
			
			==、!=、>、>=、<=
			
			System.out.println(10 == 10);//true
			System.out.println(10 != 10);//false
			System.out.println(10 > 10);//false
			System.out.println(10 >= 10);//true
			System.out.println(10 < 10);//false
			System.out.println(10 <= 10);//true
			
			总结：
				1.=是赋值号，==是判断两个值是否相等
				2.关系运算符运算的结果都是boolean值
				
			经典面试题一：输出结果为？
            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
		

	}
}

4、逻辑运算符：

&(与)、&&（短路与）、|(或) 、||（短路或）、!（非）、^（异或）

规则：

& 和 && 规则：两个有一侧为false，结果为false
| 和 || 规则：两侧有一侧为true，结果为true
^ 规则：两侧相同为false，不同为true
！规则：置反，false变成true ， true变成false

比较：做实验证明谁的效率高

& vs && 和 | vs ||

注意：

逻辑运算符运行结果都是boolean类型
&、&&、|、||、^ 两侧都是boolean类型数据

public class Test05{
	
	public static void main(String[] args){
		/**
			知识点：逻辑运算符
			
			&与	&&短路与
			|或	||短路或
			^异或
			!非
			
			//&与：前后两者都是boolean值，同时成立(true)，结果才为true
			System.out.println(true & true);//true
			System.out.println(true & false);//false
			System.out.println(false & true);//false
			System.out.println(false & false);//false
			
			//&&短路与：前后两者都是boolean值，同时成立(true)，结果才为true
			System.out.println(true && true);//true
			System.out.println(true && false);//false
			System.out.println(false && true);//false
			System.out.println(false && false);//false
			
			//& vs &&
			//&：判断前者为false后，才会判断后者
			//&&:判断前者为false后，不会判断后者，所以效率更高
			//ArithmeticException - 算数类异常
			System.out.println(false && 10/0>5);
			
			//|或：前后两者都是boolean值，有一个成立(true)，结果就为true
			System.out.println(true | true);//true
			System.out.println(true | false);//true
			System.out.println(false | true);//true
			System.out.println(false | false);//false
			
			//||短路或：前后两者都是boolean值，有一个成立(true)，结果就为true
			System.out.println(true || true);//true
			System.out.println(true || false);//true
			System.out.println(false || true);//true
			System.out.println(false || false);//false
			
			//| vs ||
			//|：判断前者为true，还会判断后者
			//||:判断前者为true，不会判断后者，所以效率更高
			System.out.println(true || 10/0>5);
			
			//^异或：前后两者都是boolean值，相同为false，不同为true
			System.out.println(true ^ true);//false
			System.out.println(true ^ false);//true
			System.out.println(false ^ true);//true
			System.out.println(false ^ false);//false
			
			//!非 - 置反
		*/
			boolean bool1 = true;
			System.out.println(!bool1);//false
			
			boolean bool2 = false;
			System.out.println(!bool2);//true
		
		

	}
}

4.1 Scanner类的运用

简介：Java提供的类，主要用于在dos窗口输入数据

使用步骤：

导包：import java.util.Scanner;

创建对象：Scanner scan = new Scanner(System.in);

调用方法(功能)：int num = scan.nextInt();

细节：

使用Java提供的类需要在java文件中的第一行导入包

使用功能必须要先创建对象

创建对象类型引用 = 新建的对象

Scanner scan = new Scanner(System.in);

方法介绍：调用方法必须使用对象所对应的引用进行调用

int num = scan.nextInt();

在窗口输入一个整数类型数字并赋值给程序中的num变量

double num = scan.nextDouble();

在窗口输入一个浮点类型数字并赋值给程序中的num变量

String str = scan.next();

在窗口输入一个字符串并赋值给程序中的str变量

5.方法调用几次，就可以在窗口输入几次

//导包
import java.util.Scanner;

public class Test07{
	
	public static void main(String[] args){
		/**
			知识点：Scanner类的使用
			
			含义：Java给我们提供的一个类，这个类的功能就是在控制台输入数据
		*/
		
		//创建Scanner类的对象
		//人类	SCAN = new 人类();
		Scanner scan = new Scanner(System.in);
		
		//调用功能
		int i1 = scan.nextInt();//在控制台输入一个int数据
		int i2 = scan.nextInt();//在控制台输入一个int数据
		double d = scan.nextDouble();//在控制台输入一个double数据
		String str = scan.next();//在控制台输入一个String数据
		
	}
}

4.2 逻辑运算符案例

import java.util.Scanner;
public class Test06{
	
	public static void main(String[] args){
		/**
			知识点：逻辑运算符的案例
			
			在dos窗口输入一个数字，判断是否在50~100的区间内
		*/
		
		//1.输入一个int数字
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入一个int值：");
		int num = scan.nextInt();
		
		//2.判断是否在50~100的区间内
		boolean bool = num>50 && num<100;
		
		//3.输出结果
		System.out.println("该值是否在50~100的区间内：" + bool);
		
	}
}

5、三目运算符/三元运算符

import java.util.Scanner;
public class Test09{
	
	public static void main(String[] args){
		/**
			知识点：表达式
			5+6:算数表达式
			5>6:关系表达式
			true & false:逻辑表达式
			
			
			知识点：三目运算符/三元运算符
			
			语法：
				数据类型 变量 = (表达式)?值1:值2;
				
			理解：
				表达式的结果必须是boolean类型
				true - 将值1赋值给变量
				false- 将值2赋值给变量
				
			做实验：
				int num = (false)?10:20;
				System.out.println(num);
			
			案例1：在控制台输入两个int类型的数字，输出最大值
				//创建Scanner类的对象scan
				Scanner scan = new Scanner(System.in);
				
				//输入两个数字
				System.out.println("请输入第一个数字：");
				int a = scan.nextInt();
				System.out.println("请输入第二个数字：");
				int b = scan.nextInt();
				
				//判断大小
				int max = (a>b)?a:b;//判断a是否大于b，如果大于就返回a，否则返回b
				
				//输出最大值
				System.out.println("最大值为：" + max);
				
			案例2：在控制台输入两个int类型的数字，输出最小值
				//创建Scanner类的对象scan
				Scanner scan = new Scanner(System.in);
				
				//输入两个数字
				System.out.println("请输入第一个数字：");
				int a = scan.nextInt();
				System.out.println("请输入第二个数字：");
				int b = scan.nextInt();
				
				//判断大小
				int min = (a<b)?a:b;//判断a是否大于b，如果小于就返回a，否则返回b
				
				//输出最大值
				System.out.println("最小值为：" + min);
				
			案例3：在控制台输入三个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);
				
			案例4：在控制台输入三个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;
				//获取最小值
				int min = (a<b)?a:b;
				min = (min<c)?min:c;
				//获取中间值
				int mid = a+b+c-max-min;
				
				System.out.println(min + "<" + mid + "<" + max);
		*/
		
	}
}

5.1、深入三目运算符

```java
public class Test10{

public static void main(String[] args){
/**

  	知识点：深入三目运算符
  	
  	扩展面试题1：
  		int a = 5;
  		System.out.println((a<5)?10.9:9);//9.0
  		
  	扩展面试题2：
  		char x = 'x';//'x' - ASCII - 120
  		int i = 10;
  		System.out.println(false?i:x);//120
  		
  	扩展面试题3：
  		char x = 'x';//'x' - ASCII - 120
  		System.out.println(false?100:x);//x
  		System.out.println(false?65536:x);//120
  		
  	三目运算符返回值规则：
  		1.值1和值2是常量的情况，就会按照取值范围大的类型返回数据
  		2.值1和值2是变量的情况，就会按照取值范围大的类型返回数据
  		3.值1是常量，值2是变量的情况，值1是否在值2所属类型的取值范围里
  			在，就按照值2类型返回数据
  			不在，就按照值1类型返回数据
  */

}
}

6、字符串拼接符

public class Test08{
	
	public static void main(String[] args){
		/**
			知识点：字符串拼接符 +
			
			+两侧都是数值，此符号为算术运算符
			+有一侧或者两侧是字符串，此符号为字符串拼接符
		*/
		
		System.out.println(1+2+"abc" + "def" +1+2);//3abcdeef12
		//				    3 +"abc" + "def" +1+2
		//					"3abc"	 + "def" +1+2
		//					"3abcdef"		 +1+2
		//					"3abcdef1"		   +2
		//					"3abcdef12"
		
	}
}

7、位运算符：

& 、 |、 ^ 、 <<、 >>、 >>>

public class Test11{
	
	public static void main(String[] args){
		/**
			知识点：位运算符
			
			&与 |或 ^异或
			<< 左移
			>> 右移
			>>>无符号位右移
			
			含义：将十进制的数据转换为二进制再进行运算
			
			//&：同位比较，两者为1，结果才为1
			byte b1 = 23;//0001,0111
			byte b2 = 25;//0001,1001
						 //0001,0001
			//23 byte - 0001,0111
			//23 int  - 0000,0000,0000,0000,0000,0000,0001,0111
			//25 byte - 0001,1001
			//25 int  - 0000,0000,0000,0000,0000,0000,0001,1001
			//17 int  - 0000,0000,0000,0000,0000,0000,0001,0001
			//17 byte - 0001,0001
			byte result = (byte)(b1 & b2);
			System.out.println(result);//17 - 0001,0001
			
			//|:同位比较，两者有1，结果就为1
			byte b1 = 23;//0001,0111
			byte b2 = 25;//0001,1001
						 //0001,1111
			System.out.println(b1 | b2);//31 - 0001,1111
			
			//^:同位比较，两者相同为0，不同为1
			byte b1 = 23;//0001,0111
			byte b2 = 25;//0001,1001
						 //0000,1110
			System.out.println(b1 ^ b2);//14 - 0000,1110
			
			&、|、^：前后两者都是数值，该符号为位运算符
			&、|、^：前后两者都是boolean值，该符号为逻辑运算符
			
			//<<：整体向左移动n位，就用n个0补位
			byte b1 = 10;//0000,1010
			//10 byte:0000,1010
			//10  int:0000,0000,0000,0000,0000,0000,0000,1010
			//40  int:0000,0000,0000,0000,0000,0000,0010,1000
			System.out.println(b1 << 2);
			
			//>>：整体向右移动n位，就用n个最高位补位
			byte b1 = 10;//0000,1010
			//10 byte:0000,1010
			//10  int:0000,0000,0000,0000,0000,0000,0000,1010
			//2		 :0000,0000,0000,0000,0000,0000,0000,0010
			System.out.println(b1 >> 2);
			
			byte b2 = -10;//1111,0110
			//-10 byte:1111,0110
			//-10  int:1111,1111,1111,1111,1111,1111,1111,0110
			//-3 	  :1111,1111,1111,1111,1111,1111,1111,1101
			System.out.println(b2 >> 2);
			
			//>>>：整体向右移动n位，就用n个0补位
			byte b1 = 10;//0000,1010
			//10 byte:0000,1010
			//10  int:0000,0000,0000,0000,0000,0000,0000,1010
			//2		 :0000,0000,0000,0000,0000,0000,0000,0010
			System.out.println(b1 >>> 2);
			
			byte b2 = -10;//1111,0110
			//-10 byte:1111,0110
			//-10  int:1111,1111,1111,1111,1111,1111,1111,0110
			//1073741821:0011,1111,1111,1111,1111,1111,1111,1101
			System.out.println(b2 >>> 2);
			
			//注意:>> 和 >>> 如果是操作整数，效果是一样的
			
			经典面试题1：使用最有效率的方式计算2*8
				System.out.println(2<<3);
				
			经典面试题2：描述下列代码的输出结果
				//-1 int:1111,1111,1111,1111,1111,1111,1111,1111
				//(byte):1111,1111
				//(char):1111,1111,1111,1111 -- char类型向上转型用0补位
				//(int) :0000,0000,0000,0000,1111,1111,1111,1111
				System.out.println((int)(char)(byte)-1);//65535
		
		*/

	}
}

8、运算符的优先级别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JZp1eN9v-1627190607367)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20210721204755900.png)]

二、转义字符

public class Test12{
	
	public static void main(String[] args){
		/**
			知识点：转义字符
			
			含义：具有特殊意义的字符本身
			
			\n：表示换行
			\"：表示一个双引号
			\'：表示一个单引号
			\\：表示一个斜杠
			\t：表示水平制表
		*/
			System.out.print("每天都是开心的\n");
			System.out.print("每天都是开心的\n");
			System.out.println("我说:\"每天都是开心的\"");
			System.out.println("我说:\'每天都是开心的\'");
			System.out.println("我说:\\每天都是开心的\\");
			
			System.out.println("3*3=9\t3*4=12\t3*5=15");
			System.out.println("4*3=12\t4*4=16\t4*5=20");
			
	}
}

三、常量

public class Test13{
	
	public static void main(String[] args){
		/**	
        知识点：常量
			含义：在程序执行过程中不可变的量
			分类：
				1.数字字面量（ps：69、100、200）
				2.字面值常量（ps："早上好","下午好"）
				3.final(最终的)修饰的变量
			ps:
            	final int i =100;
				i=200;
				System.out.println(i);
			此时会报错；
			//字面值常量和final(最终的)修饰的变量：存储在常量池中，直到项目结束才会被销毁
		*/
					final int i = 100;
					System.out.println(i);
		
		
			


	}
}

.print(“每天都是开心的\n”);
System.out.print(“每天都是开心的\n”);
System.out.println(“我说:“每天都是开心的””);
System.out.println(“我说:‘每天都是开心的’”);
System.out.println(“我说:\每天都是开心的\”);

		System.out.println("3*3=9\t3*4=12\t3*5=15");
		System.out.println("4*3=12\t4*4=16\t4*5=20");
		
}

}


## 三、常量

```java
public class Test13{
	
	public static void main(String[] args){
		/**	
        知识点：常量
			含义：在程序执行过程中不可变的量
			分类：
				1.数字字面量（ps：69、100、200）
				2.字面值常量（ps："早上好","下午好"）
				3.final(最终的)修饰的变量
			ps:
            	final int i =100;
				i=200;
				System.out.println(i);
			此时会报错；
			//字面值常量和final(最终的)修饰的变量：存储在常量池中，直到项目结束才会被销毁
		*/
					final int i = 100;
					System.out.println(i);
		
		
			


	}
}

李科码农

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java的运算符-算术、关系、逻辑、位、三目.....

一、运算符1、算数运算符：+、-、*、/、%、++、–public class Test01{ public static void main(String[] args){ /** 知识点：算数运算符的基本使用 +、-、*、/、%、++、-- int num1 = 10; int num2 = 5; int result = num1 + num2; System.out.println(result);//15 System.ou
复制链接

扫一扫