【Java】2.7运算符

运算符分类

算数运算符	一元运算符	++、--
	二元运算符	+、-、*、/、%
赋值运算符		=
扩展运算符		+=、-=、*=、/=、%=
关系运算符		>、<、>=、<=、==、!=、instanceof
逻辑运算符		&&、||、！、^
位运算符		&、|、^、~、>>、<<、>>>
条件运算符	三元运算符	？：
字符串连接符		+

2.7.1算数运算符

二元运算符的运算规则：

整数运算：

• 如果两个操作数有一个long,则结果也为long。

• 没有long时，结果为int。即使操作数全为short、byte，结果也是int。

浮点运算：

• 如果两个操作数有一个为double，则结果为double。

• 只有两个操作数都是float，结果才是float。

取模运算：

其操作数可以为浮点数，一般使用整数，结果是"余数"。"余数"符号和左边操作数相同，例如7%3=1，-7%3=-1，7%-3=1。

        //一元运算符++与--
        int a = 3;
        int b = a++;  //执行完后，b=3。先给b赋值，在自增
        System.out.println("a="+a+"\nb="+b); // a=4   b=3
        a = 3;
        b = ++a;     //执行完后，b=4。a先自增，再给b赋值
        System.out.println("a="+a+"\nb="+b);//a=4  b=4

2.7.2赋值及其扩展赋值运算符

运算符	用法举例	等效的表达式
+=	a += b	a = a + b
-=	a -= b	a = a - b
*=	a *= b	a = a * b
/=	a /= b	a = a / b
%=	a %= b	a = a % b

2.7.3关系运算符

关系运算符用来进行比较运算，关系运算符的结果是布尔值true或false。

运算符	含义	示例
==	等于	a==b
！=	不等于	a!=b
>	大于	a>b
<	小于	a<b
>=	大于或等于	a>=b
<=	小于或等于	a<=b

注意

---

• =是赋值运算符，而真正判断两个操作数是否相等的运算符是==。

• ==、！=运算符是所有（基本和引用）数据类型都可以使用的。

• >、>=、<、<=运算符仅针对数值类型（byte/short/int/long,float/double以及char）可以使用

---

2.7.4逻辑运算符

Java中的逻辑运算符如下表所示。逻辑运算的操作数和运算结果都是布尔值。

运算符		说明
逻辑与	&（与）	两个操作数为true，结果才是true，否则是false
逻辑或	|（或）	两个操作数有一个是true，结果就是true
短路与	&&（与）	只要有一个为false，则直接返回false
短路或	||（或）	只要有一个为true，则直接返回true
逻辑非	！（非）	取反，即！false为true，！true为false
逻辑异或	^（异或）	相同时为false，不同时为true

        短路与和短路或采用短路的方式是指，从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，以提高效率。

/**
 * 短路与和逻辑与
 */
public class Test05 {
    public static void main(String[] args) {
        //&&：只要有一个为false，则直接返回false
        // 1 > 2 的结果为false，那么整个表达式的结果即为false，而不再计算2>(3/0)
        boolean c = 1 >2 && 2 >(3/0);
        System.out.println(c);
        //&：两个操作数为true，结果才是true，否则是false
        // 1 > 2 的结果为false，那么整个表达式的结果即为false，还要计算2>(3/0),0不能做除数，会输出异常信息
        boolean d = 1 >2 & 2 > (3/0);
        System.out.println(d);
    }
}

2.7.5位运算符

位运算指的是进行二进制位的运算，常用的位运算符如表所示

运算符	说明
~	取反
&	按位与
|	按位或
^	按位异或
<<	左移运算符，左移1位相当于乘2
>>	右移运算符，右移1位相当于除2取商

/**
 * 位运算符 及其 面试题
 */

public class Test06 {
    public static void main(String[] args) {
        /**
         * A =   0011   1100
         * B =   0000   1101
         * -----------------------
         * A&B = 0000   1100
         * A|B = 0011   1101
         * A^B = 0011   0001  //A与B对应位相同则为0，不同则为1
         * ~B  = 1111   0010
         */
        //-------------------------
        /*效率极高！！！
        <<左移运算符，左移1位相当于乘2
        >>右移运算符，右移1位相当于除2取商
        
        //二进制位的运算
        0000 0000       0
        0000 0001       1
        0000 0010       2
        0000 0011       3
        0000 0100       4
        0000 1000       8
        0001 0000       16
         */
        System.out.println(2<<3);  //2*2*2*2=16
        System.out.println(3<<2);  //3*2*2=12
        System.out.println(5>>1);   //5/2=2
        System.out.println(5>>2);  //5/2/2=1
        System.out.println(5>>3);  //5/2/2/2=0
        
    }
}

注意

---

• &和|既是逻辑运算符，也是位运算符。如果两侧操作数都是boolean类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符。

• 不要把“^”当作数学运算“乘方”，而是“位的异或”操作。

---

2.7.6字符串连接符

"+"运算符两侧的操作数中只要有一个是字符串（String）类型，系统就会自动将另一个操作数转换为字符串然后再进行连接。

        int a = 10;
        int b = 20;
        System.out.println(""+a+b); //1020
        System.out.println(a+b+""); //30

2.7.7条件运算符

条件运算符的语法格式为：

x ? y : z

其中，x为boolean类型表达式，运算时先计算x的值，若为true，怎整个运算符的结果为表达式y的值，否则整个运算结果为表达式z的值。

        //=================三目条件运算符=================
        //   x ? y : z
        //如果x==true,则为y,否则为z
        int score = 80;
        int x = -80;
        String type = score > 60 ? "及格" : "不及格";
        int flag = x > 0 ? 1 : (x==0 ? 0 : -1);
        System.out.println(type);  //及格
        System.out.println(flag);  //-1

2.7.8运算符优先级问题

优先级	运算符	类	结合性
1	（）	括号运算符	由左至右
2	！、+（正号）、-（负号）	一元运算符	由左至右
2	~	位逻辑运算符	由右至左
2	++、--	递增与递减运算符	由右至左
3	*、/、%	算术运算符	由左至右
4	+、-	算术运算符	由左至右
5	<<、>>	位左移、右移运算符	由左至右
6	>、>=、<、<=	关系运算符	由左至右
7	==、！=	关系运算符	由左至右
8	&	位运算符、逻辑运算符	由左至右
9	^	位运算符、逻辑运算符	由左至右
10	|	位运算符、逻辑运算符	由左至右
11	&&	逻辑运算符	由左至右
12	||	逻辑运算符	由左至右
13	?：	条件运算符	由右至左
14	=、+=、-=、*=、/=、%=	赋值运算符、扩展运算符	由右至左

老鸟建议

---

逻辑与、逻辑或、逻辑非的优先级一定要熟记（逻辑非>逻辑与>逻辑或）,如a||b&&c的运算结果是a||(b&&c),而不是（a||b）&&c。

---