Java运算符：

目录：

1.算术运算符

2.位运算符

3.赋值运算符

4.比较运算符

5.逻辑运算符

6.三目运算符

7.运算符的优先级

1.算术运算符：

+  -  *  /  %

++    --    只能操作【一个】【变量】

++  --  即可放在变量之前。也可放在变量之后。

可放在变量之前，先把变量 +1（-1），然后再拿来用。可放在变量之后，先把变量拿来用，再把变量 +1（-1）.

算数运算符Test程序 及 运行结果：

public class 算术运算符Test

{  

    public static void main(String[] args)

    {

        int a = 4 + 2 / 4 + 3 * 2 - 6 % 4; 

        System.out.println(a);

        int b = 3;

        int c = a++ / ++b - a-- % b++ - --a / a-- * ++a / b--;

        // 8  / 4  -  9 % 4  -  7 / 7   * 7  / 5

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

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

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

    }

}

算数运算符Test

2.位运算符：

&      ：按位与

|       ：按位或

~     ：按位非

^     ：按位异或

<<  ：左移        在右边补 0 ，在没有数据溢出的前提下，左移 N 位，也是乘以 2 的N次方

>>  ：右移        在左边补符号位。  右移 N 位，也是除以 2 的N次方。当除不尽的情况，实际得到的整数总是比实际算术计算的值略小

>>>：无符号右移        在左边补0

位运算符Test程序 及 运行结果：

public class 位运算符Test

    {

    public static void main(String[] args)

    {

        byte bt = -2;

        byte be = 3;

        System.out.println(bt & be);// 只有上下两位都是1,才得到1

        System.out.println(bt | be);// 只要上下两位有一个1,就会得到1

        System.out.println(bt ^ be);// 只要上下两位不一样,就会得到1

        System.out.println(~bt);// 按位取反,包括符号位

        int a = 3;

        a = a << 3;  // 左移 N 位，在没有数据溢出的前提下，

                          // 相当于在右边补充 N 个0，也是乘以 2 的N次方

        System.out.println(a);

// 类似笔试题：怎么把一个数，用最快的速度乘以8？左移3位即可。

        int b = 19;

        b = b >> 3;// 右移 N 位，

                        // 相当于截断右边的N位，也就是除以2的N次方

                       // 当除不尽的情况，实际得到的整数总是比实际算术计算的值略小

        System.out.println(b);

        int c = -3;

        c = c >>> 2;    //它会把负数变成正数

        System.out.println(c);

    }

}

位运算符Test

3.赋值运算符：

=    ，把右边的值，赋给左边的变量

赋值运算符左边只能是变量

赋值语句本身是有值的，值 就等于右边被赋的值。

扩展后的赋值运算符：

        赋值运算符可以与所有的双目运算符结合，就形成了扩展后的赋值运算符。

a+=b             相当于      a = (a 的类型)(a + b)

a-=b              相当于      a = (a 的类型)(a - b)

a*=b              相当于      a = (a 的类型)(a * b)

a/=b              相当于      a = (a 的类型)(a /b)

a%=b            相当于      a = (a 的类型)(a % b)

a|=b              相当于      a = (a 的类型)(a | b)

a^=b             相当于      a = (a 的类型)(a ^ b)

a<<=b          相当于      a = (a 的类型)(a << b)

a>>=b          相当于      a = (a 的类型)(a >> b)

a>>>=b        相当于      a = (a 的类型)(a >>> b)

扩展后的赋值运算符 程序 及 运行结果：

public class 扩展后的赋值运算符

{

    public static void main(String[] args)

    {

        byte a = 20;// 20 本身是 int 型，但由于20在 -128~127 之间，系统会自动把它当成 byte

        //a = a + 2;  // 2是 int 型，表达式类型自动提升到 int 型，是错的

        a += 2;    // 相当于 a = (byte)(a + 2)  因此是对的

        //20 += a;    // 相当于 20 = (int)(20 + a)。赋值左边只能是变量，所以是错的

        int b = 3;  // 相当于 b = 0b11

        b ^= 11;    // 相当于 b = b ^ 11.  11的二进制码为 0b1011

        System.out.println("b的值为" + b);

    }

}

扩展后的赋值运算符

4.比较运算符：只能返回 true 或 false

a > b:    只有 a 大于 b，返回 true，如果 a < b，或 a == b，返回 false。

a < b:    ……

a >= b:……

a <= b:……

a == b:……

a != b:……

比较运算符的左右的东西，即可是变量，也可是直接量，也可以是表达式。

比较运算符 程序 及 运行结果：
public class 比较运算符

{

    public static void main(String[] args)

    {

        boolean bo = 5 >= 3;

        System.out.println("bo的值是" + bo);

        boolean bn = 3 >= 5;

        System.out.println("bn的值是" + bn);

        int a = 100;

        int b = 20;

        boolean b1 = (a += 2) >= (b *= 6);

        System.out.println("b1的值是" + b1);

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

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

    }

}

比较运算符

5.逻辑运算符：它的操作数要求只能是 boolean 值

它左右的操作数即可是变量，也可是直接量，也可以是表达式。

&&    ：  两个操作数都是 true 才返回 true。   只要有一个 false ，就会 false

&      ：  不会短路

||      ：  只要一个操作数是 true ，就返回 true。  只要有一个 true ，就会 true

|       ：  不会短路

!       ：  取反。单目元素，原来是 true ，变成 false；原来是 false，变成 true

^      ：  异或。只有当两个操作数不同时，才返回 true

逻辑运算符 程序 及 运行结果：

public class 逻辑运算符

{

    public static void main(String[] args)

    {

        boolean bn = true && true;

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

        int a = 6;

        boolean bo = (a++ >= 7) && (5 <= 20);

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

        boolean ba = (a++ >= 7) || (5 <= 3);

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

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

        int c = 10;

        boolean bea = (5 <= 1) & (c++ > 2);//与运算：只要一个数是false，应该直接就返回false

        System.out.println("bea的值是" + bea);//&& 只要前一个操作数是false，根本不会去计算后一个操作数，直接返回false

        System.out.println("c的值是" + c);//但 & 无论前一个操作数是什么，依然去计算后一个操作数

        int d = 5;

        boolean boo = (5 <= 20) | (d++ > 100);//或运算：只要一个数是true，应该直接就返回true

        System.out.println("boo的值是" + boo);//|| 只要前一个操作数是true，根本不会去计算后一个操作数,直接返回true

        System.out.println("d的值是" + d);//但 | 无论前一个操作数是什么，依然去计算后一个操作数

        System.out.println(true ^ false);

        System.out.println(true ^ true);

        System.out.println(false ^ false);

        System.out.println(false ^ true);

    }

}

逻辑运算符

6.三目运算符

逻辑表达式？ 表达式1 ： 表达式2

如果逻辑表达式返回true，整个表达式为表达式1的值

同理为2

三目运算符 程序 及 运行结果：

public class 三目运算符

{

    public static void main(String[] args)

    {

        int a = 100;

        a = (a *= 2) >= 200 ? a++ : a--;//这里有自加的陷阱，要注意！！！

        System.out.println("" + a);

    }

}

三目运算符

7.不同运算符有它们各自的优先级

尽量使用括号来控制优先级！

()的优先级非常高

运算符优先级表

帮记口诀：单目乘除为关系，逻辑三目后赋值。

单目：单目运算符+ –(负数) ++ -- 等

乘除：算数单目运算符* / % + -

为：位移单目运算符<< >>

关系：关系单目运算符> < >= <= == !=

逻辑：逻辑单目运算符&& || & | ^

三目：三目单目运算符A > B ? X : Y

后：无意义，仅仅为了凑字数

赋值：赋值=

以上

---

写在最后：

可以收藏方便以后查看哦！

如果你也是刚入门，强烈建议照着本文把代码自己敲一遍看看结果！

总结回顾一下之前所学习的内容：

以下纯属瞎比比，各位可以忽略

昨晚上九点多去了公司的健身房，四个角落放了四个风扇什么鬼啊，不过也还好，毕竟免费！！！练完了回去时结果西二旗地铁站竟然没有一个单车，就看到一个还是坏的，走回去就11点多了……

从去年9月份开始在学校附近办了健身卡，在我的带动下还有三个小伙伴和我一起办了，结果两个早已不见人影，一个去走专业的道路了，而我算是两者之间吧，一直陆陆续续（最多将近三周没去，比如从面试一直到来到北京租房期间）坚持到了现在，怎么说那，虽然体重没有太大变化（本意是减肥，结果一入健身深似海），但是身体感觉发生了很大的变化（好吧，只有我自己能感觉到），不过丝毫不影响我对健身的喜爱。加油吧骚年，非常喜欢一句话：文明其精神，野蛮其体魄！