Java运算符

运算符

Java语言支持如下运算符:

• 算术运算符:+，-，，l，%，++，–
• 赋值运算符=
• 关系运算符:>，<，>=，=，==，!= instanceof
• 逻辑运算符: &&，|，!
• 位运算符:&，|，^，~，>>，<<，>>>(了解! ! ! )
• 条件运算符 ?∶
• 扩展赋值运算符:+=，-=，*=，/=

算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为10，变量B的值为20：

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
–	自减: 操作数的值减少1	B-- 或 --B 等于 19

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b = 123;
        short c= 10;
        byte d= 8;

        //cast 转化
        System.out.println(a+b+c+d); //Long  如果里面有一个为Long  那这个就是结果long类型
        System.out.println(b+c+d); //int  如果没有long 结果都为int
        System.out.println(c+d); //int
    }
}

字符串连接符 “+”

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

        //字符串连接符   +  , String         "" =  一个空的字符串
        System.out.println("" + a + b); //1020  在 + 号两侧只要有一方出现 string类型  字符串   都转换成string  进行连接
        System.out.println(a + b + "");//30   如果字符串在前面会进行连接     如果字符串在后面  那么前面会依旧运算 相加

关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

public class Demo03 {
    public static void main(String[] args) {

        //关系运算符返回的结果:正确，错误布尔值
        // if
        int a = 10;
        int b = 20;
        int c = 22;
        //取余，模运算
        System.out.println(c%a); //c / a21/ 10 = 2 ... 1
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);

    }
}

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

public class Demo03 {
    public static void main(String[] args) {

        //++ -- 自增、自减一元运算符
        int a = 3;
        int b = a++;//执行完这行代码后，先给b赋值,再自增
        //相当于执行这行代码   a = a + 1;
        //System.out.println(a);
        //相当于执行这行代码   a = a + 1;
        int c = ++a; //执行完这行代码前，先自增，再给b赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算 2^3  2*2*2 = 8    很多运算，我们会使用一些工具类来操作
        double pow = Math.pow(2, 3);  //Math pow(2,3)
        System.out.println(pow);
        
    }
}

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

逻辑判断

public class Demo04 {
    public static void main(String[] args) {

        //与(and)  或(or)  非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:"+(b&&a));//逻辑与运算:两个变量都为真，结果才为true
        System.out.println("a || b:"+(a||b));//逻辑或运算:两个变量有一个为真，则结果才为true
        System.out.println("! (a &8 b):"+!(a&&b));// 如果是真，则变为假，如果是假则变为真


        //短路运算
        //当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
        int c = 5;
        boolean d = (c<4)&&( c++<4); //d = 判断 （c=5 < 4）  与  （c=5 < 4)       因为这行没有执行   所以没有自增 c 就不等于 "6"
        System.out.println(d); //false  d 等于 判断  5大于4 不成立  与   5大于4 不成立  一个错误就不成立  因为用的是 "与" 来判断
        System.out.println(c); //5       因为没有完整的循环完   所以没有自增  不等于 "6"

    }
}

位运算符

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

     /**
         //位运算符
         A = 0011 1100
         B = 0000 1101
         A&B = 0000 1100 // 对应为有 0 就是为 0  如果对应位有一个为 0  就为 0   否则为 1
         A|B = 0011 1101 // 对应为有 1 就是为 1  如果对应位有一个为 1  就为1       否则为 0
         A^B = 0011 0001 // 对应为 '相同'  就为 0      对应为'不相同'就位  1
         ~B= 1111 0010   // 对应为 '相同'  就为 1      对应为'不相同'就位  0
         2*8 =16     // 2*2*2*2

         
         效率极高！！！
         <<    *2
         >>     /2
         A = 0011 1100
         B = 0000 1101

         
         0000 0000      0
         0000 0001      1
         0000 0010      2
         0000 0011      3
         0000 0100      4
         0000 1000      8
         0001 0000      16
         
         */

条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

    public static void main(String[] args) {
        //三元运算符
        // x ? y : z
        //如果x==true, 则结果为y，否则结果为z
        int score = 50;
        String type = score < 60 ? "不及格" : "及格"; //必须掌握.
        System.out.println(type);

    }

运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr–	从左到右
一元	++expr --expr + - ～ ！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	> >= < <=	左到右
相等	== !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	| |	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
逗号	，	左到右