首页 > 代码库 > Java编程基础-运算符

Java编程基础-运算符

2024-09-05 02:38:22   222人阅读

Java中的运算符大致分为：算术运算符、赋值运算符、关系运算符、逻辑运算符和位运算符五类。

(1)、算术运算符：+  -  *  /  %  ++  --

(2)、赋值运算符：=  +=  -=  *=  /=  %=

(3)、关系运算符：==  !=  >  >=  <  <=

(4)、逻辑运算符：&  |  !  ^   &&   ||

(5)、位运算符：&  |  ~  ^  <<  >>  >>>


一、算术运算符

按照操作数数目分为单目运算符(一元运算符)和双目运算符(二元运算符)。

1、单目运算符，只有一个操作数。

单目运算符有: + (正)  - (负)  ++  (自增)   --  (自减)。

++  (自增) 和--  (自减)放在操作数前面，称为前自增(自减)，要先对被操作数作自增1或自减1运算，再进行其它的运算操作。

反之，++  (自增) 和--  (自减)放在操作数后面，称为后自增(自减)，要先进行其它运算，再进行自增1或自减1运算。

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int a = 5;  
  5.         int x, y;  
  6.         x = +a;// 正值  
  7.         System.out.println("x=" + x);// 打印结果:x=5  
  8.         y = -a;// 负值  
  9.         System.out.println("y=" + y);// 打印结果:y=-5  
  10.   
  11.         // 前自增  
  12.         int i = 5;  
  13.         System.out.println("++i=" + (++i));// 打印结果:++i=6  
  14.         System.out.println("i=" + i);// 打印结果:i=6  
  15.         // 后自增  
  16.         i = 5;  
  17.         System.out.println("i++=" + (i++));// 打印结果:i++=5  
  18.         System.out.println("i=" + i);// 打印结果:i=6  
  19.         // 前自减  
  20.         int j = 12;  
  21.         System.out.println("--j=" + (--j));// 打印结果:--j=11  
  22.         System.out.println("j=" + j);// 打印结果:j=11  
  23.         // 后自减  
  24.         j = 12;  
  25.         System.out.println("j--=" + (j--));// 打印结果:j--=12  
  26.         System.out.println("j=" + j);// 打印结果:j=11  
  27.     }  
  28.   
  29. }  

2、双目运算符，有两个操作数，运算符在操作数之间。

双目运算符有: + (加)  - (减)  * (乘)  / (除)  % (求余或者取模)。

三点注意：

(1)、在java程序中的运算符不可以省略,在数学上y=2x,可以省略乘号，但java里必须写y=2*x;

(2)、在进行除法运算时,当除数和被除数都是整数时,得到的结果也是一个整数(会忽略小数部分)。如果除法运算有小数参与,得到的结果会是一个小数.

(3)、在进行求余（%）运算时,运算结果的正负取决于被模数(%左边的数)的符号,与模数(%右边的数)的符号无关。如：-5%3=-2；而5%-3=2;

求余记住:任意正整数%2，结果要么是0,要么是1,用于切换条件。左边如果小于右边,结果是左边。左边如果等于右边,结果是0。右边是1,结果为0。

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int x = 5, y = 12;  
  5.         System.out.println(x + "+" + y + "=" + (x + y));// 相加结果:5+12=17  
  6.         System.out.println(x + "-" + y + "=" + (x - y));// 相减结果:5-12=-7  
  7.         System.out.println(x + "*" + y + "=" + (x * y));// 相乘结果:5*12=60  
  8.         System.out.println(y + "/" + x + "=" + (y / x));// 相除结果:12/5=2  
  9.         // 求余  
  10.         System.out.println(5 % -3);// 模数为负数求余结果:2  
  11.         System.out.println(-5 % 3);// 被模数为负数求余结果:-2  
  12.         System.out.println(12 % 5);// 普通求余结果:2  
  13.         System.out.println(12 % 2);// 模数为2求余结果:0  
  14.         System.out.println(12 % 1);// 模数为1求余结果:0  
  15.         System.out.println(12 % 12);// 被模数与模数相等求余结果:0  
  16.         System.out.println(5 % 6);// 被模数小于模数求余结果:5  
  17.   
  18.     }  
  19.   
  20. }  


二、赋值运算符

赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量。

赋值运算符有:

= (赋值,注意与==区别)  把等式右边的值赋给等式左边的变量。

+= (加等)把等式左右两边的值相加之后的值赋给左边的变量。  

-= (减等)   把等式左右两边的值相减之后的值赋给左边的变量。

*=  (乘等) 把等式左右两边的值相乘之后的值赋给左边的变量。

/=  (除等) 把等式左右两边的值相除之后的值赋给左边的变量。

%= (模等) 把等式左右两边的值求余之后的值赋给左边的变量。

三点注意：

(1)、在java中可以通过一条赋值语句对多个变量进行赋值。示例：
int x,y,z;
x=y=z=5;//为三个变量同时赋值。
错误写法：int x=y=z=5;

(2)、除了=,其它都是特殊的赋值运算符，以+=为例，x+=3就相当于x=x+3,首先会进行加法运算x+3,再将运算结果赋值给变量x。其它赋值运算符都可以此类推。

(3)、在使用+=、-=、*=、/=、%=运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显示的声明。


三、关系运算符

关系运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。

关系运算符有:==(相等)  !=(不等)   >(大于)   >= (大于等于)   <(小于)   <=(小于等于)

注意:不能将关系运算符==写成赋值运算符=,二者是不同的运算符,运算结果是不同的。切记！

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         System.out.println(12 == 21);// 判断是否相等,结果为:false  
  6.         System.out.println(5 != 6);// 判断是否不相等,结果为:true  
  7.         System.out.println(4 > 3);// 判断4是否大于3,结果为:true  
  8.         System.out.println(4 >= 4);// 判断4是否大于等于4,结果为:true  
  9.         System.out.println(3 < 5);// 判断3是否小于5,结果为:true  
  10.         System.out.println(6 <= 5);// 判断6是否小于等于5,结果为:false  
  11.   
  12.     }  
  13.   
  14. }  


四、逻辑运算符

逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型。

逻辑运算符有:

&(与)：两边都为真结果为真,否则为假。   

|(或)  :两边只要有一个为真,结果为真,否则为假。

! (非)  :非真则为假,非假则为真。

^ (异或)   :两边相同则为假,两边不同则为真。

&&(短路与) :两边都为真结果为真,否则为假。

||(短路或):两边只要有一个为真,结果为真,否则为假。

特别注意：

&与&&的区别：&无论左侧条件为真还是为假,都会计算判断右侧的条件。而&&当左侧条件为假时，不会计算判断右侧的条件,当左侧为真，才会继续判断右侧的条件。因为与运算结果为真必须满足左右两边条件都为真。

|与||的区别：|无论左侧条件为真还是为假,都会计算判断右侧的条件。而||当左侧条件为真时，不会计算判断右侧的条件，当左侧为假时，才会继续判断右侧的条件。因为或运算结果为真只要满足一边为真即可。

程序开发中建议使用&&(短路与) 和||(短路或)，提高执行效率。

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // ！非 真变假，假变真  
  5.         System.out.println(!(12 > 21));// 结果为:true  
  6.         System.out.println(!true);// 结果为:false  
  7.         // ^异或 两操作数一真一假，结果才为真,否则为假  
  8.         int x = 18;  
  9.         System.out.println(x >= 18 ^ x < 18);// 结果为:true  
  10.         System.out.println(x < 18 ^ x == 18);// 结果为:true  
  11.         System.out.println(x != 18 ^ x > 18);// 结果为:false  
  12.         System.out.println(x == 18 ^ x <= 18);// 结果为:false  
  13.         // 逻辑与&、短路与&& 两操作数同真,结果为真,否则为假  
  14.         int y = 5;  
  15.         System.out.println(y > 5 & y <= 5);// 结果为:false  
  16.         System.out.println(y >= 5 && y < 5);// 结果为:false  
  17.         System.out.println(y != 5 & y < 5);// 结果为:false  
  18.         System.out.println(y == 5 && y <= 5);// 结果为:true  
  19.         // 逻辑或|、短路或|| 两操作数同假,结果为假,否则为真  
  20.         int z = 2;  
  21.         System.out.println(z != 18 | z > 18);// 结果为:true  
  22.         System.out.println(z >= 18 || z == 18);// 结果为:false  
  23.         System.out.println(z <= 18 | z > 18);// 结果为:true  
  24.         System.out.println(z != 18 || z == 18);// 结果为:true  
  25.         // 短路与测试  
  26.         int i1 = 18;  
  27.         System.out.println(i1 != 18 && i1++ > 18);// 结果为:false  
  28.         System.out.println("i1:" + i1);// 由于左边条件为false,所以右边的表达式未作判断,i1结果为:18  
  29.         int i2 = 18;  
  30.         System.out.println(i2 != 18 & i2++ > 18);// 结果为:false  
  31.         System.out.println("i2:" + i2);// 左边条件为false,右边依然需要判断,i1结果为:19  
  32.         // 短路或测试  
  33.         int j1 = 18;  
  34.         System.out.println(j1 == 18 || j1++ > 18);// 结果为:true  
  35.         System.out.println("j1:" + j1);// 由于左边条件为true,所以右边不作判断,j1结果为:18  
  36.         int j2 = 18;  
  37.         System.out.println(j2 == 18 | j2++ > 18);// 结果为:true  
  38.         System.out.println("j2:" + j2);// 左边条件为true,右边依然需要判断,j2结果为:19  
  39.     }  
  40.   
  41. }  

奉上逻辑运算符真值表：

技术分享

五、位运算符

位运算符是针对二进制数的每一位进行运算的符号，它是专门针对数字0和1进行操作的。

位运算符有:&(按位与) |(按位或) ~(取反) ^(按位异或) <<(左移)  >>(右移)  >>>(无符号右移)

位运算操作的真值表与逻辑运算符的真值表完全相同。只是位运算的操作数和结果都是二进制整数。

(1)、按位与运算符“&”是将参与运算的两个二进制数进行与运算，如果两个二进制位都为1，则该位的运算结果为1，否则为0.

例如：将6和11进行与运算，6对应的二进制数是00000110，11对应的二进制数是00001011.具体演算过程如下：

00000110

                 &     00001011

                         00000010

运算结果为00000010，对应数值为2.

(2)、 按位或运算符“|”是将参与运算的两个二进制数进行或运算，如果二进制位上有一个值为1，则该位的运行结果为1，否则为0.

例如：将6与11进行或运算。

00000110

                 |      00001011

                         00001111

运算结果为00001111，对应的数值是15.

(3)、取反运算符“~”只针对一个操作数进行操作，如果二进制位是0，则取反值为1，如果是1，则取反值为0.

例如：将6进行取反运算。

  ~     00000110                                 

         11111001

运算结果为11111001，对应的数值是-7

(4)、按位异或运算符“^”是将参与运算的两个二进制数进行异或运算，如果二进制位相同，则值为0，否则为1.

例如：将6和11进行异或运算。

00000110

         ^      00001011

                 00001101

运算结果为00001101，对应数值是13.

一个数异或同一个数两次，结果还是那个数。

(5)、左移运算符“<<”就是将操作数所有二进制位向左移动一位，运算时，右边的空位补0，左边移走的部分舍去。（一个整数向左移动几位就乘以2的几次幂），越移越大。

例如：将11左移动一位。

<<1        00001011                                

               00010110

运算结果为00010110，对应数值是22.（亦或是11*2的1次方=22）

(6)、右移运算符“>>”就是将操作数所有二进制位向右移动一位。运算时，左边的空位根据原数的符号补0或1（原来是负数就补1，是正数就补0）（一个整数向右移动几位就除以2的几次幂，高位时0就补0，是1就补1），越移越小。

例如：将11右移一位

>>1        00001011                                

               00000101

运算结果为00000101，对应的数值是5.

(7)、无符号右移运算符“>>>”就是将操作数所有二进制位向右移动一位，左边的空位补0（即不考虑原数的正负情况,最高位都用0补）

例如：将11无符号右移一位

>>>1      00001011                                

               00000101

运算结果为00000101，对应的数值是5.


特殊的运算符:条件运算符(三目运算符)

格式为：<表达式1>?<表达式2>:<表达式3>

执行流程：先计算表达式1的值，当表达式1为true,则把表达式2的值作为整个表达式的结果；当表达式1为false,则将表达式3的值作为整个表达式的结果。


附运算符优先级表

 

优先级 运算符 结合性
1 . [] () 从左向右
2 ++ -- ~ !(数据类型) 从右向左
3 */ % 从左向右
4 + - 从左向右
5 << >> >>> 从左向右
6 < ><= >= 从左向右
7 == != 从左向右
8 & 从左向右
9 ^ 从左向右
10 | 从左向右
11 && 从左向右
12 || 从左向右
13 ?: 从右向左
14 =  *=  /= %=  +=  -= <<=  >>=  >>>= &=  ^=  /= 从右向左

 

Java编程基础-运算符


联系
我们