运算符和表达式

#运算符指的是有运算功能的符号。

在Java中，主要有以下几种运算符。

(1) #算术运算符。

(2) #赋值运算符

(3) #自增运算符、#自减运算符。

(4) #关系运算符

(5) #逻辑运算符

(6) #位运算符。

(7) #三元运算符

#表达式指的是把操作数(参与运算的变量或常量等)和运算符按一定的语法规则组成的符号序列，其主要作用是说明运算过程并返回运算结果。

表达式的值可以作为其他表达式的操作数，嵌套成更复杂的表达式。在编程过程中，我们会用到大量运算符和表达式。

1.1 算术运算符和算术表达式

算术运算符是用来处理算术运算的，是最简单、最常用的运算符。Java中常用的算术运算符有“+”“_”“*”“/”等。

算术表达式是指按一定的语法规则，把算术运算符和操作数连起来的式子，例如“a+b”“a*b”等。具体如下表所示。

1.1.1 除法运算

在Java语法中，如果两个整数进行除法运算，那么不论是否被整除，运算结果都会是整数。例如:

System.out.println(1 5/2);      //输出的运算结果为7System.out,println( 1 0/3 );    //输出的运算结果为3

由上述可知，运算结果只是去掉了小数部分，而不会进行四舍五入。

1.1.2 求余运算

#求余运算就是求余数的运算，#运算结果是除法运算中的余数。

例如:

System,out.println(17%2)； //输出的运算结果为1System.out.println(10%3)； //输出的运算结果为1System.out.printin(3%10)； //编出的运算结果为3System.out.println(8%2)；  //输出的运算结果为0

1.1.3 关于0的问题

和数学运算一样，0可以做被除数，但不可以做除数。当0为被除数时，除法运算和求余运算的运算结果都是0。

例如:

System.out.println(0/6);  //输出的运算结果为0System out.println(0%6);  //输出的运算结果为0

不过，虽然用0做除数可以在Java语法中通过编译，但在实际运行时，系统会提示“java.lang.ArithmeticException”的异常。

2 赋值运算符和赋值表达式

基本赋值运算符是“=”，其作用是将赋值运算符右边的值赋给左边的变量。赋值运算符的左边必须是变量，而不能是常量或表达式。

赋值表达式是指按照一定的语法规则，把赋值运算符和操作数进行组合的式子如“x=14”“a=false”等。

接下来看看下面的代码。

a=b=c=11;

由于自右向左是赋值运算符的运算(结合性)顺序,因此在上述语句中,变量b、c的值都是11。

在赋值时，程序会先计算赋值运算符右边的值，然后把运算后的值赋给左边的变量，因此下面的表达式语句也是对的。

int num = 8;num=num+6;//首先获取num 变量的值，与6相加，再将和赋值给变量num

除了基本赋值运算符外，Java中还有复合的赋值运算符。

下表所示的复合值运算符是与算术运算符相对应的，因此也被称为算术赋值运算符。算术赋值运符和基本赋值运算符一样，左边只能是变量。

表算术赋值运算符

请看下面的示例。

public class AssignmentOperationTest{     publicstaticvoidmain(String[] args){        int a=10,b=5;        //此语句执行完以后，a-15        System out.println("a+=b:a="+(a+=b));        //此语句执行完以后，a-10        System.out.println("a-=b:a=" +(a--b));        //此语句执行完以后，a-50        System.out.println("a*_b:a=" + (a*-b));        //此语句执行完以后，a-10        System.out.println("a/=b:a=" + (a/-b));        //此语句执行完以后，a-0       System.out.println("a% b:a=" +(a%=b));     }}

程序运行结果为:

a+-b:a-15a--b:a-10a*-b:a-50a/=b:a=10a%=b/:a=0

说明:上述代码中，如果运算符“”两边是整数，那输出结果也会是整数;如果两边有一个浮点数或都是浮点数，那输出结果也会是浮点数。

3 自增运算符和自减运算符

在实际运用中，经常需要让一个整数变量的值增加或减少。有一类运算符就是专门处理这类情况的，这就是“自增运算符(++)”和“自减运算符(--)”。自增运算符的作用是使操作数的值加1，而自减运算符的作用是使操作数的值减1。

前面提到过的算术运算符和赋值运算符都是二元运算符，而自增运算符和自减运算符都是一元运算符。

简单来说，二元运算符指的是有两个操作数的运算符，而元运算符只有一个操作数。

自增运算符和自减运算符可以放在操作数之后，也可以放在操作数之前。比如表达式a++和++a都相当于a=a+1，而表达式a--和--a都相当于 a=a-1。不过虽然++和--放在变量的前面或后面不影响最终的输出数值，但它们的实际运行过程是有区别的。++和--运算符放在变量名前面时，被称为前缀运算符;而++和--运算符放在变量名后面时，被称为后级运算符。

前缀运算符是自增1或自减1后再参与运算,而后级运算符是先运算,然后再将运算后的变量值自增1或自减1。

例如:

public class IncreAndDecreOperationTest{    publicstaticvoidmain( java.lang String[] args){        int a=10,b=5；        //a先把值赋给c，然后再自增1        int c=a++；        //b先自增1，然后再把自增后的值赋值给d        int d=++b;        //输出结果为10        System.out.println(c)；        //输出结果为11        System.outprintln(a):        //输出结果为6        System,out.println(d);        //输出结果为6        System out.println(b);    }}

在上述案例中，当++运算符放在变量a后面时，程序先输出变量a的值，然后变量a自增1，即由10自增为1;而当++运算符放在量b量b的值增加1，然后输出变量b的值。

4 关系运算符和关系表达式

#关系运算也被称为比较运算。当有两个值需要进行比较时，就要用到关系运算符了。

用关系运算符把两个操作数连起来，就构成了关系表达式。#关系表达式的值是逻辑值，即true(真)和false(假)。

Java中有六种关系运算符，如下表所示。

由上表可知，当表达式成立时，运算结果为true;当表达式不成立时，运算结果为false。

对整数、浮点数和字符型数据进行比较时，所有关系运算符都可以选用;对其他数据类型进行比较时，可以选用“等于”和“不等于”运算符。

5 逻辑运算符和逻辑表达式

做一些简单的比较时可以使用关系运算符，但要做复杂的比较时，就要用到逻辑运算符了。

Java中常用的逻辑运算符有:与运算符(&和&&)、或运算符(和)、异或运算符(^)、取反(非)运算符(!)。

#逻辑表达式是用逻辑运算符把逻辑量或关系表达式连起来的式子。逻辑表达式J值是逻辑值，即true(真)和false(假)。

下面来看看几种逻辑运算符的含义和区别

5.1 与运算符(&和&&)

如果用&或&&把两个关系表达式连接在一起，那么只有当两个关系表达式的值都为true时，它们组合成的逻辑表达式的值才会为true。

例如，如需找出库存量(stock)小于等于10件且价格(price)大于20元的商品，也就是说其中有两个关系表达式，即“slock小于等于10”和“price大于20”。

现在需找出同时满足这两个条件的产品，所以要用与运算符把这两个表达式组合在一起。

boolean yesOrNo =(stock<=10)&(price>20);Systcm.out.println(yesOrNo);

在这个例子中，“stock<=10”和“price>20”被与运算符连接在一起，那么只有表示库存量stock的值小于等于10，且商品价格price的值大于20，也就是两个表达式的值都为真(true)时，整个表达式“(stock<=10)&(price>20)”的值才为真。

需注意，虽然&和&&都可以用于“与”的运算，但它们也有一些区别，当&&左侧表达式为false时，程序会直接返回运算结果alse，而不会再计算&&右侧表达式的值。只有当&&左侧表达式为tue时,程序才会运算右侧表达式。

例如

public class AndOperationTest {   public statie voidmain(String[] args){       //声明两个变量x和y，并分别初始为10积8       int x=10.y 8;       boolean yesOrNo;       //运算符&&左侧运算结果为true、右侧表达式被运算       yesOrNo=(x>9)&&(y++>7):       //输出结果:yesOrNo-true       System.out.println("yesOrNo="-yesOrNo)       //输出结果：y=9       System.out.println("y-"*v)       //重置变量y的值       y=5;       //运算符&&左侧运算结果为1alst，在表法式不被运算       yesOrNo-(x>10)&&(y++>9)       //输出结果:yesOrNomfalse       System.out,printa("yesOrNe-" yesOre).       //输出结果:y=6       System aut.prin!n"y"+y)    }}

&则与&&不同，不管&左侧运算结果是什么，程序都会对右侧表达式进行运值都为true时，它们组合成的逻辑表达式的值才会为true。

例如

public class AndOpcrationTest2{    publicstaticvoidmain(String[]args)        //声明两个变量x和y，并分别初始化为11和7        int x=11.y=7;        boolean yesOrNo;        //运算符&左侧运算结果为true，右侧表达式被运算        yesOrNo=(x>9)&(y++>5);        //输出结果:yesOrNo=true        System.outprintln("yesOrNo=" yesOrNo):        //输出结果:y=8        System.out.println("y "+y);        //重置变量y的值        y=5;        //运算符&左侧运算结果为false，右侧表达式仍然被运算        yesOrNo-(x>12)&(y++>5);        //输出结果:yesOrNo=false        System out.println("yesOrNo="+ycsOrNo);        //输出结果:y=6       System,oul.printin("y="+y);    }}

通过上面的两个例子，可以明确运算符&&和&的区别。

相对来说，&&的运算比&更简洁，所以&&也被称为“简洁与”。

因为&&可以直接根据左侧表达式的false值返回整个表达式的值，所以也被称为“短路与”。

5.2 或运算符( | 和 || )

如果用|或||把两个关系表达式连在一起，那么只要其中任意一个表达式的值为値tue,它们组成的逻辑表达式的值就为true。#只有两个关系表达式的值同为false时它们组合而成的逻辑表达式的值才为false。

例如:

boolean yesOrNo =(stock<=10)|(price>20);System.out.println(yesOrNo);

在这个例子中，如果库存量stock的值小于等于10，或者表示商品价格的变量price的值大于20，也就是只要两个表达式的值有一个为真，那整个表达式的值就为真。

特别说明的是,虽然|和||都可以用于“或”的运算,但它们也有一些区别当左侧表达式返回true时，程序会直接返回运算结果true，而不会再计算||右侧表达式。

例如

public class OrOperation1{     publicstaticvoidmain(String[] args){         //声明两个变量x和y，并分别初始化为10和7         int x=l0,y=7;         boolean yesOrNo；         //运算符||左侧运算结果为tue时，右侧表达式不会再进行运算         yesOrNo=(x>9)(y++>5);         //输出结果:yesOrNo=true         System.out.println("yesOrNo="+yesOrNo)；         //输出结果:y=8         System.out.println("y="+y)；         //重置变量y的值         y=5;         //运算符||左侧运算结果为alse时，右侧表达式将会进行运算         yesOrNo-(x>12)|(y++>5);         //输出结果:yesOrNo=true         System.outprintln("yesOrNo="+yesOrNo);         //输出结果:y=6         System.out.println("y="+y);     }}

运算符|则有所不同，不管|左侧运算结果是什么，程序都会对右侧表达式进行运算，然后返回整个逻辑表达式的值。

例如:

public classOrOperation2{    public static void main(String[l args)       //声明两个变量x和y，并分别初始化为10积7       int x=10，y=7;       boolean yesOrNo;       //运算符|左侧运算结果为true、右侧表达式被运算       yesOrNo=(x>10)(y++>5);       //输出结果:yesOrNo=true       System.out.println("yesOrNo-"+yesOrNo)       //输出结果:y=8       System.out.println("y="+y);       //重置变量y的值       y=5;       //运算符|左侧运算结果为false、右侧表达式仍然被运算       yesOrNo-(x>10)|(y++>5);       //输出结果:yesOrNo=false       System.out.println("yesOrNo-”*yesOrNo);       //输出结果:y=6      System.out.println("y-"+y)   }}

由上面的例子可以看出，运算符的运算方式与&&有些相似，而|则与&有些相似。

前面说过，&&被称为“简洁与”和“短路与”，基于相似的原因,#‖也被称为“简洁或”和“短路或”。

5.3 异或运算符(^)

当两个关系表达式通过异或运算符(^)联系在一起时，只要这两个关系表达式的值不一致，比如一个为true，另一个为false，那么它们组成的逻辑表达式就会返回true;如果两个关系表达式的值一致，比如都为true或都为false，它们组成的逻辑辽表达式就会返回flse。

例如:

System.out,println(true ^ true);   //输出结果为flseSystem.out,println(true ^ false);  //输出结果为trueSystem.out,println(false ^true);   //输出结果为trueSystem.out.printin(false ^ false): //输出结果为false

5.4 取反(非)运算符(!)

顾名思义，#取反(非)运算符(!)可以对操作数进行取反。

如果运算数的值true,经过取反运算后,结果将变为false;如果运算数的值为false,经过取反运算后结果将变为true。

例如:

System.out.println(!true);  //输出结果为falseSystem.out.println(!false): //输出结果为true

6 位运算符

#位运算符是指在二进制级别上对操作数进行运算，并返回运算结果为整数的运算符。

换个角度说,就是#将二进制数作为操作数的表示形式,然后#按位进行布尔运算运算的结果为二进制。

在Java语言中，位运算符主要有六类七种，即:

1) #按位与运算符(&)

2) #按位或运算符(1)

3) #按位异或运算符(^)

4) #按位取反运算符(~)

5) #左移位运算符(<<)

6) #右移位运算符(>>和 >>>)

6.1 按位与运算符(&)

参与运算的两个数按位进行与运算时，如果相对应位都是1、则该位的运算结果为1，否则为0。这分为四种情况:0&0=0，0&1-0，1&0-0，1&1=1。例如:

System.out.printin(8 & 10)； //输出结果为8

进行上述运算时要把十进制8和10分别转换为二进0000000000001000和00000000 00001010。运算过程为：

    00000000 00001000

&  0000000000001010

————————————

    00000000 00001000     (十进制8的二进制表示)

故输出结果为8。

6.2 按位或运算符(1)

参与运算的两个数按位进行或运算时，如果相对应位都是0，则该位的运算结果亻屏为β0，剂否嗆規执则为1。这也分为四种情况:010=0，011=1，110=1，11=1。例如:

System.out.println(7|8)；     //输出结果为15

在上述示例中，运算时要把十进制7和8分别转换为二进制0000000000000111和0000000000001000。运算过程为:

    00000000 000001110

|   00000 00001000

——————————————

    00000000 00001111   (十进制15的二进制表示)

故输出结果为15。

6.3 按位异或运算符(^)

参与运算的两个数按位进行异或运算，如果相对应位都是1或都是0，则该位的运算结果为0，否则为1。这也分为四种情况:0^0=0，0^1=1，1^0=1，1^1=0。例如:

System.out.println(9 ^17);      //输出结果为24

进行上述运算时要把十进制9和17分别转换为二进制0000000000001001和0000000000010001。运算过程为:

     00000000 00000111

|    00000000 00001000

————————————————

     00000000 00011000    (十进制24的二进制表示)

故输出结果为24。

6.4 按位取反运算符(~)

#按位取反运算符(~)是一元运算符,只能操作一个操作数。如果是对1进行取反则运算箦果为0;如果是对0进行取反，则运算结果为1。

也就是说:~1=0，~0=1。

System.out.println(~19);   //输出结果为-20

在上述示例中，运算时要把十进制19转换为二进制0000000000010011。

运算过程为:

       ~00000010011

   ———————————

       11111111 11101100        (十进制 -20 的二进制表示)

故输出结果为-20。

6.5 左移位运算符(<<)

#左移位运算符(<<)会把所有二进制位向左移动运算符右边指定的位数，右边的空位则以0补位。

一般来说，在不产生溢出时，数据左移n位，就相当于该数乘以2的n次方。

例如:

int a=16:System.out.println(a<<2);           //输出结果为64

在上述示例中，运算时要把十进制16转换为二进制0000000001000000a<<2，也就是说要向左移2位。

运算过程为:

     00000000 00010000   <<2

—————————————————

           00000000 01000000              (十进制 64的二进制表示)

故输出结果为64。

注意:负数左移时，在负数的二进制位右边补0。一个数在左移的过程中可能会变成正数，也可能会变成负数，所以负数左移不会对符号位进行特殊处理。如果一直左移，数最终会变成0。

6.6 右移运算符(>>和 >>>)

#右移位运算符(>>)与左移位运算符(<<)相对应，是把所有二进制位向右移动运算符右边指定的位数，左边的空位不能直接补0，而是根据原数的正负补0或1(原数是正数就补0，原数是负数就补1)。

一般来说，数据右移n位，就相当于该数除以2的n次方。

例如:

int a==14:System.out.println(a>>1);     //输出结果为-7

在上述示例中，运算时要把十进制-14转换为二进制1111111111110010a>>1，也就是说要右移1位。运算过程为：

   111111111 1110010                 >>1

——————————

    1111111111001                      (十进制-7的二进制表示)

故输出结果为-7。

#右移位运算符>>>的用法与>>基本一致，区别是在进行右移位运算时，#左边的空位不考虑正负，一律补0。

例如:

int a==14；System.out.println(a>>>1);          //输出结果为2 147 483 641

在上述示例中，运算时要把十进制-14转换为二进制1111111111110010a>>>1表示右移1位。运算过程为:

     11111111 11110010                >>>1

————————————

          01111111 11111001                (十进制2147483641的二进制表示)

故输出结果为2147483641。

7 三元运算符

#三元运算符是Java中仅有的有三个操作数的运算符。

其语法格式如下。

逻辑表达式?表达式1:表达式2

执行顺序是:先执行逻辑表达式，如果返回true，则输出表达式1的值;如果返回false，则输出表达式2的值。

例如:

int achievement;···System.out.println(achievement>59?"及格!":"不及格!");

在上述示例中，要先对表达式“achievement>59”进行判断，如果代表分数的变量 achievement 的值大于 59、那么输出“及格!”，否则输出“不及格!"!

在三元表达式中，对问号(?)前的逻辑表达式的判断结果有且只有两种，其输出结果要么取表达式1的值，要么取表达式2的值，只能在两者中取其一。

例如:

int x=46,y=34,z72-x>y?++x:++y；System.outprintln(z)；     //输出结果为47System aut println(x)；     //输出结果为47System.out.prnrtln(y)；     //输出结果为34

8 运算符的优先级

在Java语法中，如果表达式中存在多个运算符，那么#Java会根据运算符的优先级来决定执行的顺序。

当有多个优先级相同的运算符时，就按结合性(从左到或从右到左)进行排序。运算符的优先级顺序如下表所示。

如需让优先级较低的运算符先进行运算，则可以用括号将需要调整的运算符和操作数括起来。

括号可以多层嵌套，如果有多个括号嵌套，会优先运算内层的括号。

因为括号具有这样的功能，所以在实际开发时，不用专门去记各种运算符的优先级别，只要合理使用括号来确保运算的顺序即可。