JavaEE基础知识

最新推荐文章于 2022-01-12 21:06:46 发布

行走的人型机器

最新推荐文章于 2022-01-12 21:06:46 发布

阅读量186

点赞数

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

本文链接：https://blog.csdn.net/qq_40781005/article/details/112696651

版权

Java 专栏收录该内容

51 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的算术运算符(+、-、*、/、%、++, --)的使用、类型转换规则，以及赋值运算符、关系运算符、逻辑运算符和位运算符的实例。还包括了三目运算符、字符串拼接和位操作技巧，以及常见面试题的解答。

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

一、运算符 +、-、*、/、%、++、–

1.算数运算符的基本运用

int num1 = 100;
int num2 = 5;

int result = num1 + num2;
System.out.println(result);//105

System.out.println(num1 - num2);//95

System.out.println(100 * 5);//500
System.out.println(100 / 5);//20
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

2.深入算术运算符

1.两个byte类型做运算，会先自动转型成int类型再做运算

byte num1 = 10;
byte num2 = 20;

//byte 10:0000,1010
//int  10:0000,0000,0000,0000,0000,0000,0000,1010
//byte 20:0001,0100
//int  20:0000,0000,0000,0000,0000,0000,0001,0100
//运算后的结果 int 30：0000,0000,0000,0000,0000,0000,0001,1110

byte result = (byte)(num1 + num2);

System.out.println(result);

2.两个short类型做运算，会先自动转型成int类型再做运算

short num1 = 10;
short num2 = 20;

//short 10:0000,0000,0000,1010
//int  10:0000,0000,0000,0000,0000,0000,0000,1010
//short 20:0000,0000,0001,0100
//int  20:0000,0000,0000,0000,0000,0000,0001,0100
//运算后的结果 int 30：0000,0000,0000,0000,0000,0000,0001,1110

short result = (short)(num1 + num2);

System.out.println(result);

3.除了byte和short，其余的数值类型会自动转型成取值范围较大的类型

int num1 = 10;
float num2 = 20.12F;

float result = num1+num2;

System.out.println(result);

4.字节型char类型做运算会取ASCII的值

char c = 'a';//ASCII-97
int result = c + 1;
System.out.println(result);// 98

5.两个char类型做运算，会先自动转型成int类型再做运算

char c1 = 'a';//ASCII-97
char c2 = 'b';//ASCII-98

char result = (char)(c1 + c2);
System.out.println(result);// ? 超出char的取值范围

6.++a; 和 a++;效果是一样的，都是自增1，分号代表着一条执行语句的结束，不管是先加还是后加，都给加1了

int a = 10;
//++a;
//a++;
System.out.println(a);

3.深入算数运算符2

经典面试题一：输出结果为？
int a = 8;
int b = (a++)+(++a)+(a*10);
//a = 10
//b = 8 + 10 + 10*10
System.out.println(b);//118

经典面试题二：输出结果为？
int i = 0 ;   
i = ++i; 
//底层实现：
//i = i + 1;
//i = i;
System.out.println(i);//1

经典面试题三：输出结果为？
int i = 0;   
i = i++;  
//底层实现：(最开始有一个变量temp记录了i最初的值，最后再赋值给i，相当于i没有变化)	
//int temp = i; temp->0
//i = i + 1;	i   ->1
//i = temp;		i   ->0
System.out.println(i);//0  

扩展：++num的底层实现
byte num1 = 10;
++num1;//底层实现：num1 = (byte)(num1 + 1)
System.out.println(num1);//11

int num2 = 10;
++num2;//底层实现：num2 = (int)(num2 + 1)
System.out.println(num2);//11

二、赋值运算符

1赋值运算符的基本运用

int num = 10;	

num += 5;//num = (int)(num+5);	// 15
num -= 5;//num = (int)(num-5);  // 5
num *= 5;//num = (int)(num*5);  // 50
num /= 5;//num = (int)(num/5);  // 2
num %= 3;//num = (int)(num%3);  // 1

System.out.println(num);//1

经典面试题一：输出结果为？
int a,b;//一次性声明两个int类型的变量
a = b = 100;
System.out.println(a);//100
System.out.println(b);//100

经典面试题二：下面的两种写法结果分别是？
short s = 1; 
s = s+1;//报错：变量s是short类型，数字字面量1是int类型，运算结果是int类型

short s=1; 
s += 1;//s = (short)(s+1);

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

三、关系运算符：==、!=、>、 <、 >=、 <=

1.关系运算符的基本运用

==:判断两个值是否相等
!=:判断两个值是否不相等

boolean bool = 10 == 20;
System.out.println(bool);//false
System.out.println(10 != 20);//true
System.out.println(10 > 20);//false
System.out.println(10 >= 20);//false
System.out.println(10 < 20);//true
System.out.println(10 <= 20);//true
注意：
1.关系运算符的结果都是boolean类型，true或者 false
2.不要将==用成=

经典面试题一：输出结果为？
int x = 10;
int y = 10;
boolean flag = (x == y);
System.out.println(flag);//true
flag = (x = y);//报错：boolean与其他类型不兼容（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

四、逻辑运算符&(与)、&&（短路与）|(或) 、||（短路或）^（异或）!（非）

1.逻辑运算符的基本运用

//& 与：两者都成立(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

//&& 短路与：两者都成立(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>0);

//| 或：两者有一个成立(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

//|| 短路或：两者有一个成立(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，不会判断后者，所以效率更高
//ArithmeticException:数学计算类异常
System.out.println(true || 10/0>0);

//^ 异或：两者相同，结果为false
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
System.out.println(!true);//false
System.out.println(!false);//true

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

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

1.三目运算符基本使用

语法规则：
数据类型变量 = (表达式)?值1:值2;

理解：
表达式的结果必须是boolean类型
true - 返回值1
false- 返回值2

int result = (false)?10:20;
System.out.println(result);// 20

面试题

扩展面试题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
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类型
	值2在值2类型的取值范围外，返回值1类型

六、字符串拼接符 +

+两侧都是数值，此符号为算数运算符，否则为字符串拼接符

System.out.println(1 + 2 + "abc" + 1 + 2);
//				   	 3   + "abc" + 1 + 2
//					 "3abc"      + 1 + 2
//					 "3abc1"         + 2
//					 "3abc12"

七、位运算符： & 、 |、 ^ 、 <<、 >>、 >>>

1.位运算的基本运用

byte num1 = 21;//0001,0101
byte num2 = 22;//0001,0110

//& 与：同位比较，两者为1，结果则为1
//byte 21:0001,0101
//int  21:0000,0000,0000,0000,0000,0000,0001,0101
//byte 22:0001,0110
//int  22:0000,0000,0000,0000,0000,0000,0001,0110
//运算结果 - int 20：0000,0000,0000,0000,0000,0000,0001,0100
//(byte)(运算结果) 强转成了byte类型:0001,0100
byte result = (byte)(num1 & num2);
System.out.println(result);//20 - 0001,0100

//| 或：同位比较，两者有1，结果就为1
System.out.println(num1 | num2);//23 - 0001,0111

//^ 异或：同位比较，两者相同为0，不同为1
System.out.println(num1 ^ num2);//3 - 0000,0011

注意：
&、|、^：前后两者是数值，此符号为位运算符
&、|、^：前后两者是boolean值，此符号为逻辑运算符


//<<左移:整体向左移动n位，就用n个0补到最低位
byte b1 = 8;//0000,1000
//0010,0000  
//byte 8:0000,1000
//int  8:0000,0000,0000,0000,0000,0000,0000,1000
//<<   2:0000,0000,0000,0000,0000,0000,0010,0000
System.out.println(b1 << 2);//32 - 0010,0000

//>>右移：整体向右移动n位，就用n个最高位补到最高位
byte b2 = 8;//0000,1000
//byte 8:0000,1000
//int  8:0000,0000,0000,0000,0000,0000,0000,1000
//>>   2:0000,0000,0000,0000,0000,0000,0000,0010
System.out.println(b2 >> 2);//2 - 0000,0010

byte b3 = -8;//1111,1000
//byte -8:1111,1000
//int  -8:1111,1111,1111,1111,1111,1111,1111,1000
//>>    2:1111,1111,1111,1111,1111,1111,1111,1110
System.out.println(b3 >> 2);//-2 - 1111,1110	

//>>>无符号位右移：整体向右移动n位，就用n个0补到最高位
byte b4 = 8;//0000,1000
//byte 8:0000,1000
//int  8:0000,0000,0000,0000,0000,0000,0000,1000
//>>>  2:0000,0000,0000,0000,0000,0000,0000,0010
System.out.println(b4 >>> 2);//2 - 0000,0010

byte b5 = -8;//1111,1000
//byte -8:1111,1000
//int  -8:1111,1111,1111,1111,1111,1111,1111,1000
//>>>   2:0011,1111,1111,1111,1111,1111,1111,1110
System.out.println(b5 >>> 2);//1073741822

经典面试题一：用最有效率的方式计算出2*8
System.out.println(2 << 3);

经典面试题二：以下代码的执行结果是什么？
//考点：char类型的取值范围没有负数，所有补位就用0
//-1:1111,1111,1111,1111,1111,1111,1111,1111
//(byte)(-1):1111,1111
//(char)(byte)(-1):1111,1111,1111,1111
//(int)(char)(byte)(-1):0000,0000,0000,0000,1111,1111,1111,1111

System.out.println((int)(char)(byte)-1);//65535