Java运算符——————03

Hsu.Y

于 2022-04-20 19:19:05 发布

阅读量1k

点赞数 1

文章标签： java-ee

本文链接：https://blog.csdn.net/qq_54287371/article/details/124303300

版权

一、基本运算符

1.知识点：算数运算符的使用

+（加）、-（减）、*（乘）、/（除）、%（余）、++（自增）、--（自减）

1.1.运算符的使用

package com.company;

public class Test02 {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        int c = a +b;
        System.out.println(c);  //15
        System.out.println(a - b);  //5  
        System.out.println(a * b);  //50
        System.out.println(a / b);  //2
        System.out.println(a % b);  //0

        System.out.println(a++);    //10  执行a+1
        System.out.println(a);      //11  输出结果

        System.out.println(--b);    //4   执行a-1并执行输出a-1
        System.out.println(b);      //4


        int i = 0;
        i = i++;
        System.out.println(i);      //0   
            /**输出为0是因为在执行代码的时候栈类最开始存放了i=0，在执行 i=i++的过程中 i++执行                                                    
             完了但是并没有存在栈中，所以输出的i是上面定义的int i= 0*/
     

    }
}

2.深入运算符

深入点1：两个byte类型做运算，会先转成int类型，再做运算，获得到的结果自然是int类型

public class Test02{
	
	public static void main(String[] args){			
			byte b1 = 10;
			byte b2 = 20;
			
			//byte b1 - 10：0000,1010   一个字节占8个比特位
			//int       10：0000,0000,0000,0000,0000,0000,0000,1010  一个int类型占32个比特位
			//byte b2 - 20：0001,0100   向下转型为强制转型
			//int       20：0000,0000,0000,0000,0000,0000,0001,0100

			//int 		  ：0000,0000,0000,0000,0000,0000,0001,1110   result的2进制
			//(byte)	  ：0001,1110
			byte result1 = (byte)(b1 + b2);
			System.out.println(result1); //30
			
    }
}

深入点2：两个short类型做运算，会先转成int类型，再做运算，获得到的结果自然是int类型

public class Test02{
	
	public static void main(String[] args){			
            short s1 = 10;
			short s2 = 20;
			
			//short s1 - 10：0000,0000,0000,1010  short类型占8个比特位
			//int        10：0000,0000,0000,0000,0000,0000,0000,1010  向上转型补首位符
			//short s2 - 20：0000,0000,0001,0100
			//int		 20：0000,0000,0000,0000,0000,0000,0001,0100
			//int		   ：0000,0000,0000,0000,0000,0000,0001,1110
			//(short) 	   ：0000,0000,0001,1110
			short result2 = (short)(s1 + s2);
			System.out.println(result2);     //30
			
    }
}

深入点3：输出数据的类型

public class Test02{
	
	public static void main(String[] args){			
        byte b = 10;
			short s = 10;
			int i = 10;
			long l = 10;
			float f = 10;
			double d = 10;
			
			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(i + f);//float    整型和浮点型相加转为浮点型 比如2.1+2=4.1
			System.out.println(l + f);//float
			System.out.println(l + d);//double    原理同浮点型一样
			System.out.println(f + d);//double
    }
}

深入点4：char类型和数值型做运算，都会获取ASCII的值

public class Test02{
	
	public static void main(String[] args){			
        char c = 'a';//'a'的ASCII是97  char类型转化是转化对应的ASCII码
		int i = c + 1;   //97+1
		System.out.println(i);//98
    }
}

深入点5：++a; 和 b++; 没有区别，因为;是执行语句的结束，不管先加还是后加，都加1

public class Test02{
	
	public static void main(String[] args){			
        int a = 10;
		++a;
		System.out.println(a);//11
			
		int b = 10;
		b++;
		System.out.println(b);//11
			
    }
}

深入点6：++的底层一定要强转

public class Test02{
	
	public static void main(String[] args){			
            int a = 10;
			++a;
			//底层：
			//a = (int)(a + 1);
			System.out.println(a);//11
			
			byte b = 10;
			++b;
			//底层：
			//b = (byte)(b + 1);
			System.out.println(b);
    }
}

经典面试题一：输出结果为？

                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);
               //i = i;
               System.out.println(i);//1

经典面试题三：输出结果为？
               int i = 0;
               i = i++;
               //底层原理：
               //int temp = i;--> temp记录了i最初的值（0）
               //i = (int)(i+1); --> i确实得到自增了
               //i = temp;-->把i最初的值再次赋值给i
               System.out.println(i);//0

3.赋值运算符

符号：=（赋值）、+=（加等于）、-=（减等于）、*=（乘等于）、/=（除等于）、%=（余等于）

注意：
=为赋值号，将右边的值赋值给左边的变量

public class Test03{
	
	public static void main(String[] args){
				
			int i = 100;
		
			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);
	}
}

经典面试题一：输出结果为？
               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);

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

4.关系运算符

符号：==（等于）、!=（不等于）、>（大于）、>=（大于等于）、<（小于）、<=（小于等于）

注意：
               =是赋值号
               ==是判断两个值是否相等
               !=是判断两个值是否不相等

总结：关系运算符的结果一定是boolean类型

public class Test04{
	
	public static void main(String[] args){
			
			System.out.println(10 == 10);//true
			System.out.println(10 != 10);//false
			System.out.println(5 > 10);//false
			System.out.println(5 >= 10);//false
			System.out.println(5 < 10);//true
			System.out.println(5 <= 10);//true

	}
}

       经典面试题一：输出结果为？
           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);//比较两个boolean类型(b1、b2)是否相同
           System.out.println(b3);//false
           boolean b4 = (b1 = b2);//b2赋值给b1，b1再赋值给b4
           System.out.println(b4);//false

5.逻辑运算符

符号：&与，&&短路，与 |或，||短路或， ^异或，!非

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

public class Test05{
	
	public static void main(String[] args){
			
			//&与：两侧存放boolean的值，条件都成立(true)，结果才为true
			System.out.println(true & true);//true
			System.out.println(false & true);//false
			System.out.println(true & false);//false
			System.out.println(false & false);//false
			
			//&&短路与：两侧存放boolean的值，条件都成立(true)，结果才为true
			System.out.println(true && true);//true
			System.out.println(false && true);//false
			System.out.println(true && false);//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(false | true);//true
			System.out.println(true | false);//true
			System.out.println(false | false);//false
			
			//||短路或：两侧存放boolean的值，条件有一侧成立(true)，结果就为true
			System.out.println(true || true);//true
			System.out.println(false || true);//true
			System.out.println(true || false);//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(false ^ true);//true
			System.out.println(true ^ false);//true
			System.out.println(false ^ false);//false
			
			//!非：置反（true变成false，false变成true）
			boolean bool1 = true;
			System.out.println(!bool1);//false
			
			boolean bool2 = false;
			System.out.println(!bool2);//true			
		
	}
}

6.字符拼接

知识点：字符串拼接符

符号：+

注意：
+两侧都是数值，该符号为算术运算符
+有一侧为字符串或者两侧都是字符串，该符号为字符串拼接符

public class Test07{
	
	public static void main(String[] args){
		
		System.out.println(1 + 2 + "abc" + "def" + 1 + 2);
		//				 	 3   + "abc" + "def" + 1 + 2
		//					   "3abc"    + "def" + 1 + 2
		//								"3abcdef"+ 1 + 2
		//								   "3abcdef1"+ 2
		//									 "3abcdef12"
	}
}

二、Scanner类

含义：Java给我们提供的一个类，主要是作用于在控制台输入的功能

注意：类是抽象的概念，去操作类的实体(对象)

总结：
               1.使用不了类，我们使用的是类的对象，所以要new(创建)对象
               2.创建Scannner对象时，使用到了Scanner类，所以要导包
               3.对象怎么使用？调用该对象的方法/功能（nextInt、nextDouble、next）

//导包
import java.util.Scanner;
public class Test06{
	
	public static void main(String[] args){
		
		//创建Scanner类的对象
		Scanner scan = new Scanner(System.in);
		
		//操作对象的功能
		int i = scan.nextInt();//在控制台输入int数据，将这个数据赋值给变量i
		
		//操作对象的功能
		double d = scan.nextDouble();//在控制台输入double数据，将这个数据赋值给变量d
		
		//操作对象的功能
		String str = scan.next();//在控制台输入字符串数据，将这个数据赋值给变量str（String-字符串）
		
		System.out.println(i);
		System.out.println(d);
		System.out.println(str);
	}
}

2.1表达式

5+6 ：算数表达式

5>6 ：关系表达式

true & false ：逻辑表达式

2.2三目运算符的使用

       语法结构：
               变量 = (表达式)?值1:值2;

           理解：表达式的结果必须是boolean类型的
               true-- 将值1赋值给变量
               false- 将值2赋值给变量

           做实验：
               int num = (false)?10:20;
               System.out.println(num); //20

需求1：在控制台输入两个int数字，获取最大值

import java.util.Scanner;
public class Test08{
	
	public static void main(String[] args){
				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;
				
				System.out.println("最大值为：" + max);
	}
}

需求2：在控制台输入两个int数字，获取最小值

import java.util.Scanner;
public class Test08{
	
	public static void main(String[] args){
				
				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;
				
				System.out.println("最小值为：" + min);
	}
}

需求3：在控制台输入三个int数字，获取最大值

import java.util.Scanner;
public class Test08{
	
	public static void main(String[] args){
				
				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数字，从小到大输出

import java.util.Scanner;
public class Test08{
	
	public static void main(String[] args){
				
        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.3三目运算符的深入

三目运算符的返回值规则：

1.值1和值2都是常量的情况，按照取值范围大的类型返回数据

2.值1和值2都是变量的情况，按照取值范围大的类型返回数据

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

public class Test09{
	
	public static void main(String[] args){
			知识点：三目运算符的深入
			
			扩展面试题1：
				int a = 5;
				System.out.println((a<5)?10.9:9);//9.0
				
			扩展面试题2：
				char x = 'x';//ASCII - 120
				int i = 10;
				System.out.println((false)?i:x);//120
				
			扩展面试题3：
				char x = 'x';//ASCII - 120
				System.out.println((false)?100:x);//x
				System.out.println((false)?100000:x);//120
	}
}

2.4位运算符

含义：将十进制的数据转换为二进制，再做运算

符号：&（与）、|（或）、^（异或）、<<（左移）、>>（右移）、>>>（无符号位右移）

public class Test10{
	 
	public static void main(String[] args){
			
			byte b1 = 22;//0001,0110
			byte b2 = 27;//0001,1011
			
			//&：同位比较，两者为1，结果才为1
			//byte b1 - 22：0001,0110
			//int	  - 22：0000,0000,0000,0000,0000,0000,0001,0110
			//byte b2 - 27：0001,1011
			//int     - 27：0000,0000,0000,0000,0000,0000,0001,1011
			//int	  - 18：0000,0000,0000,0000,0000,0000,0001,0010
			//(byte)  - 18：0001,0010
			byte result1 = (byte)(b1 & b2);
			System.out.println(result1);//18 - 0001,0010
			
			//|：同位比较，两者有1，结果就为1
			//byte b1 - 22：0001,0110
			//int	  - 22：0000,0000,0000,0000,0000,0000,0001,0110
			//byte b2 - 27：0001,1011
			//int     - 27：0000,0000,0000,0000,0000,0000,0001,1011
			//int	  - 31：0000,0000,0000,0000,0000,0000,0001,1111
			//(byte)  - 31：0001,1111
			byte result2 = (byte)(b1 | b2);
			System.out.println(result2);//31 - 0001,1111
			
			//^：同位比较，两者相同为0，不同为1
			//byte b1 - 22：0001,0110
			//int	  - 22：0000,0000,0000,0000,0000,0000,0001,0110
			//byte b2 - 27：0001,1011
			//int     - 27：0000,0000,0000,0000,0000,0000,0001,1011
			//int	  - 13：0000,0000,0000,0000,0000,0000,0000,1101
			//(byte)  - 13：0000,1101
			byte result3 = (byte)(b1 ^ b2);
			System.out.println(result3);//13 - 0000,1101
/**			
			& | ^：此符号前后两侧都是数值，此符号为位运算符
			& | ^：此符号前后两侧都是boolean值，此符号为逻辑运算符
*/			
			//<<左移：整体向左移动n位，就用n个0补位
			byte b1 = 4;
			//byte b1 - 4：0000,0100
			//int     - 4：0000,0000,0000,0000,0000,0000,0000,0100
			//<< 2 	     ：0000,0000,0000,0000,0000,0000,0001,0000
			System.out.println(b1 << 2);//16
			
			//>>右移：整体向右移动n位，就用n个符号位补位(正数符号位为0，负数符号位为1)
			byte b2 = 32;
			//byte b2 - 32：0010,0000
			//int     - 32：0000,0000,0000,0000,0000,0000,0010,0000
			//>> 3        ：0000,0000,0000,0000,0000,0000,0000,0100
			System.out.println(b2 >> 3);//4
			
			byte b3 = -27;
			//byte b3 - -27：1110,0101
			//int     - -27：1111,1111,1111,1111,1111,1111,1110,0101
			//>> 3		   ：1111,1111,1111,1111,1111,1111,1111,1100
			System.out.println(b3 >> 3);
			
			//>>>无符号位右移：整体向右移动n位，就用n个0补位
			byte b4 = 32;
			//byte b4 - 32：0010,0000
			//int     - 32：0000,0000,0000,0000,0000,0000,0010,0000
			//>>> 3       ：0000,0000,0000,0000,0000,0000,0000,0100
			System.out.println(b4 >> 4);//4
			
			byte b5 = -27;
			//byte b5 - -27：1110,0101
			//int     - -27：1111,1111,1111,1111,1111,1111,1110,0101
			//>>> 3		   ：0001,1111,1111,1111,1111,1111,1111,1100
			
			System.out.println(b5 >>> 3);//536870908
/**			
			注意：>> 和 >>> 在处理正数时是没有区别的
			
			面试题：使用最有效率的方式计算4*8
				System.out.println(4<<3);
*/
	}
	
}

2.5转义字符

含义：用来表示有特殊意义的字符本身

           \" 表示一个双引号
           \' 表示一个单引号
           \\ 表示一个斜杠
           \n 表示换行
           \t 水平制表（作用：对齐）

public class Test11{
	 
	public static void main(String[] args){
			
			System.out.println("老师说:\"用良心做教育，做真实的自己\"");
			System.out.println("老师说:\'用良心做教育，做真实的自己\'");
			System.out.println("老师说:\\用良心做教育，做真实的自己\\");
			
			System.out.print("用良心做教育\n");
			System.out.print("做真实的自己");
			
			System.out.println("冲田杏梨\t爱田奈奈\t北条麻衣");
			System.out.println("三上悠亚\t小峰由衣\t桃谷绘里香");
//          使用final(最终)修饰的变量
			final int i = 100;
			System.out.println(i);
	}
	
}

知识点：常量
           含义：在程序执行过程中不可改变的量
           分类：
               1.数字字面量（程序中出现的数字）
               2.字面值常量（双引号括起来的内容）
               3.使用final(最终)修饰的变量

三、总结

1.运算符（先使用，在深入）
   算数运算符：+、-、*、/、%、++、--
   赋值运算符：=、+=、-=、*=、/=、%=
   关系运算符：==、!=、>、>=、<、<=
   逻辑运算符：&、&&、|、||、^、！
       & vs &&
       | vs ||
   字符串拼接符：+
   三目运算符（重点：返回值规则及面试题）
   位运算符（了解）
   运算符的优先级别

2.Scanner类 -- 学会运用

Hsu.Y

关注

1
点赞
踩
0

收藏

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

一、基本运算符1.知识点：算数运算符的使用+（加）、-（减）、*（乘）、/（除）、%（余）、++（自增）、--（自减）1.1.运算符的使用package com.company;public class Test02 { public static void main(String[] args) { int a = 10; int b = 5; int c = a +b; System.out.println(c
复制链接

扫一扫