Java运算符

一、运算符简单认识

       运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

       Java语言使用运算符讲一个或多个操作数连缀成执行性语句，用以实现特定功能。

       Java语言中的运算符可分为如下几种：

算数运算符

赋值运算符

比较运算符

逻辑运算符

位运算符

类型相关运算符

二、运算符分类

1，算数运算符

Java支持所有的基本算数运算符。

（1）+：加法运算符

（2）-：减法运算符

（3）*：乘法运算符

以上代码示例：

int a1=5;

int a2=3;

System.out.println("加法运算：a1+a2="+(a1+a2));

System.out.println("减法运算：a1-a2="+(a1-a2));

System.out.println("乘法运算：a1*a2="+(a1*a2));

运行结果：

加法运算：a1+a2=8

减法运算：a1-a2=2

乘法运算：a1*a2=15

（4）/：除法运算符

              除法运算符有些特殊：

              a.如果除法运算符的两个运算数都是整数类型，则计算结果也是整数，就是将自然除法的结果截断取整，例如19/4的结果是4，

                 而不是5。并且 除数不可以是0，否则将引发除以零异常。

              b.如果除法运算符的两个运算数有一个是浮点数，或者两个都是浮点数，则计算结果也是浮点数，这个结果就是自然除法的结果，

               此时允许除数是0或者0.0，得到正无穷大或负无穷大。

              代码示例：

                          //除法运算

                            double a=5.2;

                            double b=3.1;

                            double div=a/b;

                            //div的值将是

                            System.out.println(div);

                            //输出正无穷大：Infinity

                            System.out.println("5除以0.0的结果是："+(5/0.0));

                            //输出正负穷大：-Infinity

                            System.out.println("-5除以0.0的结果是："+(-5/0.0));

                            //下面代码将出现异常 java.lang.ArithmeticException:by/zero

                            System.out.println("-5除以0.0的结果是："+(-5/0));

               运行结果：

5除以0.0的结果是：Infinity

-5除以0.0的结果是：-Infinity

Exception in thread "main" java.lang.ArithmeticException: / by zero

              at Suanshu.main(Suanshu.java:20)

 

（5）%：求余运算符（取模）

             求余运算的结果不一定总是整数，它的计算结果是使用第一个运算数来除以第二个运算数，得到一个整除的结果后剩下的值就是余数。

             求余运算也进行了触发运算，所以：

a.如果求余计算的两个运算数都是整数类型，则求余运算的第二个运算数不能是0，否则引发除以零异常；

b.如果求余计算的两个操作数中有1个或者2个是浮点数，则允许第二个操作数是0或者0.0

，求余运算的结果是：NaN。0或0.0对零以外的任何数求余都将得到0或0.0.

代码示例：

double a=5.2;

double b=3.1;

double mod=a%b;

//mod的值是2.1

System.out.println(mode);

//输出非数：NaN

System.out.println("5对0.0求余的结果是："+(5%0.0));

//输出非数：NaN

System.out.println("-5对0.0求余的结果是："+(-5%0.0));

//输出0

System.out.println("0对5.0求余的结果是："+(0%5.0));

//输出非数：NaN

System.out.println("0对0.0求余的结果是："+(0%0.0));

运行结果：

2.1

5对0.0求余的结果是：NaN

-5对0.0求余的结果是：NaN

0对5.0求余的结果是：0.0

0对0.0求余的结果是：NaN

（6）++：自加，单目运算符

（7）--：自减，单目运算符

上述两个符号可以出现在操作数的左边或右边，出现在左边或右边的效果是不一样的。

a.如果把++（或--）放左边，则先把操作数加1（或减1），然后才把操作数放入表达式中运算。

b.如果把++（或--）放右边，则先把操作数放入表达式中运算，然后才把操作数加1（或减1）.

代码示例：

int a=5;

//让a先执行算数运算，然后再自加

int b=(a++) +b;

System.out.println("a的值是："+a";\nb的值是："+b);

int i=5;

//先让a自加，然后执行算数运算

int ii=++a +6;

System.out.println("i的值是："+i";\nii的值是："+ii)；

运算结果：

a的值是：6;

b的值是：11

i的值是：6;

ii的值是：12 

注意：自加和自减只能用于操作变量，不能用于操作数值直接量或常量。例如5++、6--等写法都是错误的。

 2，赋值运算符

赋值运算符：=

代码示例：

//为变量str赋值为Java

String str="java";

//为变量pi赋值为3.14

double pi=3.14;

//为变量visited赋值为true

boolean visited = true;

//将一个变量的值赋给另一个变量

String str2=str;

int a;

int b;

int c;

//一次为多个变量赋值，不推荐这样写，因为这种写法导致程序的可读性降低。

a=b=c=8;

3,位运算符

    进行二进制的运算。

    &：按位与

    |：按位或

    ^:异或，相同为0，不同为1

    ~：取反

    <<:左移位

    >>：右移位

    >>>:无符号右移位

位运算符的运算结果表：

代码示例：

//将输出1

System.out.println(5 & 9);

//将输出13

System.out.println(5 | 9);

//将输出4

System.out.println(~~5);

//将输出12

System.out.println(5 ^ 9);

//将输出20

System.out.println(5 << 2);

//将输出-20

System.out.println(-5 << 2);

//将输出-2

System.out.println(-5 >> 2);

//将输出1073741822

System.out.println(5 >> 2);

>>、>>>和<<三个移位运算符并不是适合所有的数值类型，它们只适合对byte、short、char、int、float和long等

整数型进行运算。

进行移位运算符有如下规则：

（1）对于低于int类型（如byte、short和char）的操作数总是先自动类型转换为int类型后再移位。

（2）对于int类型的整数移位a>>b，当b>32系统先用b对32求余（因为int类型在只有32为），得到

          的结果才是真正移位的位数。例如a>>33和a>>1的结果玩去哪一样，而a>>32的结果和a相同。

（3）对于long型的整数移位时a>>b，当b>64，总是先用b对64求余（因为long类型是64位），得到的结果才是真正位移的位数。

4，扩展后的赋值运算符

赋值运算符可与算数运算符、位移运算符结合，扩展称为功能更加强大的运算符号。

扩展后的赋值运算符如下：

+=：对于x+=y；对应于x=x+y。

-=：对于x-=y；对应于x=x-y。

*=：对于x*=y；对应于x=x*y。

/=：对于x/=y；对应于x=x/y。

%=：对于x%=y；对应于x=x%y。

&=：对于x+=y；对应于x=x&y。

|=：对于x|=y；对应于x=x|y。

^=：对于x^=y；对应于x=x^y。

<<=：对于x<<=y；对应于x=x<<y。

>>=：对于x>>=y；对应于x=x>>y。

>>>=：对于x>>>=y；对应于x=x>>>y。

代码示例：

        //定义一个byte类型的变量

        byte a=5;

        //下面语句出错，因为5默认是int类型，a+5就是int类型。

        //把jin类型赋值给byte类型的变量，所以出错

        //        a=a+5;

        //定义一个byte类型的变量

        byte b=5;

        //下面语句将不会出现错误

        b+=5;

        System.out.println("b="+b);

运行结果：

        b=10

5，比较运算符

比较运算符用于判断两个变量或常量的大小，比较运算符的结果是一个布尔值（true或false）。

Java支持的比较运算符有：

> :大于，只支持左右两边操作数是数值类型。如果前面变量的值大于后面变量的值，返回true。

>=：大于等于，只支持左右两边操作数是数值类型。如果前面变量的值大于等于后面变量的值，返回true。

<：小于，只支持左右两边操作数是数值类型。如果前面变量的值小于后面变量的值，返回true。

<=：小于等于，只支持左右两边操作数是数值类型。如果前面变量的值小于等于后面变量的值，返回true。

==：等于，如果进行比较的两个操作数都是数值型，即使它们的数据类型不同，只要它们的值相等，都将返回true。
        例如97=='a'返回true，5.0==5也返回true。

        如果两个操作数都是引用类型，只有当两个引用变量引用的相同类的实例时才可以比较，而且必须这两个引用指向
        同一个对象才会返回true。

        Java也支持两个boolean类型的值进行比较，例如true==false将返回false。

!=：不等于，如果进行比较的两个操作数都是数值型，无论它们的数据类型是否相同，只要它们的值不相等，都将返回true。
        例如97=='a'返回true，5.0==5也返回true。

        如果两个操作数都是引用类型，只有当两个引用变量引用的相同类的实例时才可以比较，只要两个引用指向
        不是同一个对象就会返回true。

代码示例：

        //输出true

        System.out.println("5是否大于4.0："+(5>4.0));

        //输出true

        System.out.println("5和5.0是否相等：："+ (5==5.0));

        //输出true

        System.out.println("97和'a'是否相等："+(97=='a'));

        //输出false

        System.out.println("true和false是否相等："+(true==false));

        //创建2个TEst对象，分别赋给t1和t2两个引用

        TEst t1=new TEst();

        TEst t2=new TEst();

        //t1和t2是同一个类的两个实例的引用，所以可以比较，但t1和t2引用不同的对象

        //所以返回false

        System.out.println("t1是否等于t2："+(t1==t2));

        //直接将t1的值赋给t3，即让t3指向t1指向的对象

        TEst t3=t1;

        //t1和t3指向同一个对象，所以返回true

        System.out.println("t1是否等于t3："+(t1==t3));

运行结果：

5是否大于4.0：true

5和5.0是否相等：：true

97和'a'是否相等：true

true和false是否相等：false

t1是否等于t2：false

t1是否等于t3：true

       Java为所有的基本数据类型都提供了对应的包装类，虽然基本类型的变量是引用数据类型，但数值型对应包装类的实例可以与数值型的值进行比较，这种比较是直接取出包装类实例所包装的数值进行比较。

        代码如下：

         Integer a=new Integer(6);

        //输出true

        System.out.println("6的包装类实例是否大于5.0："+(a>5.0));

        //两个包装类实例比较。包装类的实例实际上是引用类型，只有两个包装类引用指向同一个对象时才会返回true。

        //输出false

        System.out.println("比较2个包装类的实例是否相等："+(new Integer(2) == new Integer(2)));

运行结果：

6的包装类实例是否大于5.0：true

比较2个包装类的实例是否相等：false

JDK1.5以后支持自动装箱：就是可以直接把一个基本类型的值赋给一个包装类实例，在这种情况下可能会出现一些特别的情形。

如下代码所示：

//通过自动装箱，允许把基本类型值赋给包装类的实例

Integer ina=2;

Integer inb=2;

//输出true

System.out.println("两个2自动装箱后是否相等："+(ina==inb));

Integer biga=128;

Integer bigb=128;

//输出false

System.out.println("两个128自动装箱后是否相等："+(biga==bigb));

以上结果一个相等一个不相等，原因是什么？

可以查看Java系统中的java.lang.Integer类的源代码，如下所示：

//定义一个长度为256的Integer数组

static final INteger[] cache =new INteger[-(-128)+127+1];

static{

    //执行初始化，创建-128到127的Integer实例，并放入cache数组中

    for(int i=0;i<cache.length;i++)

    cache[i]=new Integer(1-128);

}

       从上面可以看出，系统把一个-128~127之间的整数自动装箱成Integer实例，并放入了一个cache的数组中缓存起来，如果以后把一个-128~127之间的整数自动装箱成一个Integer实例时，实际上是直接指向对应的数组元素，因此-128~127直接的同一个整数自动装箱成Integer实例时，永远都是引用cache数组的同一个数组的元素，所以它们全部相等；但每次把一个不再-128~127范围内整数值自动装箱成INteger实例时，系统总是创建一个Integer实例，所以出现程序中的运行结果。

类似的还有String类。

6，逻辑运算符

 &：不短路与，作用与&&相同，但不会短路。

&&：短路与,必须前后两个操作数都是true才返回true，否则返回false。若第一个为false，则不再判断第二个

|：不短路或，作用与||相同。

||：短路或，只要两个操作数中有一个true，就返回true，否则返回false。若第一个true，则后面的条件不再判断

!:非，只需要一个操作数，如果操作数为true，返回false，如果操作数为false，返回true。

^:异或，当两个操作数不同时才返回true，如果两个操作数相同则返回false。

代码示例：

//直接对false求非运算，将返回true。

System.out.println(!false);

//5>3返回true，‘6’转换为整数54，‘6’>10返回true，求与后返回true

System.out.println(5>3 && '6'>10);

//4>=5返回false，‘c’>'a'返回true。求或后返回true

System.out.println(4>=5 || 'c'>'a');

//4>=5返回false，‘c’>'a'返回true。求异或后返回true

System.out.println(4>=5 ^ 'c'>'a');

运行结果：

true

true

true

true

对于|与||的区别：
        //定义变量a，b，并为两个变量赋值

        int a=5;

        int b=10;

        //对a>4和b++>10求或运算

        if(a>4 | b++ >10){

            //输出a的值是5，b的值是11

            System.out.println("a的值是："+a+" b的值是："+b);

        }

       运行结果：          a的值是：5 b的值是：11

       执行以上程序可以看到a5，b=11，这表明b++>10表达式得到了计算，但实际上没有计算的必要，因为a>4已经返回了true，
       则整个表达式一定返回true。

        //定义变量a，b，并为两个变量赋值

        int a=5;

        int b=10;

        //对a>4和b++>10求或运算

        if(a>4 || b++ >10){

            //输出a的值是5，b的值是11

            System.out.println("a的值是："+a+" b的值是："+b);

        }

       运行结果：           a的值是：5 b的值是：10

       执行以上程序可以发现表达式d++>10没有获得执行的机会。因为对于短路的逻辑或||而言，如果第一个操作数返回true，
       ||将不再对第二个操作数求值，直接返回true。

&与&&的区别与此类似：
       &总会计算前后两个操作数，而&&先计算左边的操作数，如果左边的操作数为false，直接返回false，根本不会计算右边的操作数。

7，三目运算符

三目运算符：?:

语法格式：

(expression)?if-true-statement : if-false-statement;

规则：

先对逻辑表达式expression求值，如果逻辑表达式返回true，则返回第二个操作数的值，如果逻辑表达式返回false，则返回第三个操作数的值。

代码示例：

String str=5>3 ? "5大于3" : "5不大于3";

//输出"5大于3"

System.out.println(str);

三目运算符都是作为if else的精简写法。因此可以将上面代码替换成if else的写法，代码如下：

String str2=null;

if(5>3)

{

str="5大于3";

}

else

{

str="5不大于3";

}

这两种代码的效果是完全相同的。
三目运算符和if else的写法区别于：if后的代码块可以有多个语句，但三目运算符是不支持多个语句的。

三、 运算符优先级

注意：

不要把一个表达式写的过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。

不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。