前言

  在Java中可以支持很多的基本运算，下面介绍各个java中各个运算符的使用方法。

1 Java运算符

Java 语言支持的运算符

算术运算符： +，-，*，/，%，++（自增），--（自减）
赋值运算符： =
扩展赋值运算符： +=，-=，*=，/=
关系运算符： >，<，>=，<=，==，!=
逻辑运算符：&，|， &&，||，!，^
位运算符： &，|，^，~ ， >>，<<，>>>
条件运算符(三目运算符)： A ? B : C

• 相关概念辨析
  运算符 操作符：+ - Operator
  表达式 ：5+6 expression
  操作数： 5 6 Operand
  语句： int m =5+6; Sentence

运算的优先级：

实际开发中我们不会写特别复杂的表达式，你要想先算谁就用括号()圈起来即可

2 算数运算符：+ - * / % ++ - -

加法中加号+的作用

（1）表示正数
（2）表示相加操作
（3）进行字符串的拼接

/**
 * 算数运算符 加法
 **/

public class demo1 {
    public static void main(String[] args){
        //表示正数：
        System.out.println(+5); // 5
        //相加操作：
        System.out.println(5+6); // 11
        System.out.println(5+'6'); // 59
        //字符串的拼接：
        //规则：+左右两侧的任意一侧有字符串，那么这个加号就是字符串拼接的作用，结果一定是字符串
        int num = 56;
        System.out.println("num="+num); // "num=56"
        System.out.println(5+6+"7"); // 11+"7"--->"117"
        System.out.println(5+'6'+"7"); // 59 +"7"--->"597"
        System.out.println("5"+6+"7"); // "56"+"7"--->"567"
        System.out.println("5"+'6'+"7"); // "56"+"7"--->"567"
        System.out.println("5"+'6'+'7'); // "56"+'7'--->"567"
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

++自增和- -自减法操作的使用

看++在前还是在后，如果a++：先运算，后加1 如果++a，先加1，后运算（- -自减同理）

public class Test{
        public static void main(String[] args){
                int a = 5;
                a++;//理解为：相当于  a=a+1 操作  
                System.out.println(a);//6
                a = 5;
                ++a;//理解为：相当于  a=a+1 操作  
                System.out.println(a); //6
                //总结：++单独使用的时候，无论放在前还是后，都是加1操作
                
                //将++参与到运算中：
                //规则：看++在前还是在后，如果++在后：先运算，后加1   如果++在前，先加1，后运算
                a = 5;
                int m = a++ + 7;//先运算  m=a+7  再加1：  a = a+1 
                System.out.println(m);//12
                System.out.println(a);//6
                
                a = 5;
                int n = ++a + 7;//先加1  a=a+1  再运算：  n = a+7 
                System.out.println(n);//13
                System.out.println(a);//6
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3 扩展赋值运算符： +=，-=，*=，/=

1. a+=10；等价于 a = a+10；（其他同理）
2. a+=b 和 a=a+b 的区别：a+=b可读性稍差 编译效率高，底层自动进行类型转换。而a=a+b可读性好，编译效率低手动进行类型转换

4 关系运算符： >，<，>=，<=，==，!=

关系运算符的使用

public class Test{
        public static void main(String[] args){
                //>，<，>=，<=，==，!=
                //关系运算符最终结果：要么是true要么是false
                System.out.println(4>9);//false
                System.out.println(4<9);//true
                System.out.println(4>=9);//false
                System.out.println(4<=9);//true
                System.out.println(4==9);//false
                System.out.println(4!=9);//true
                System.out.println((5<9)!=(6==8));//true
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5 逻辑运算符：&，|，&&，||，!，^

逻辑运算符的定义和特点

逻辑运算符是进行逻辑运算的，运算符左右连接的都是 布尔类型 的操作数，最终表达式的结果也是布尔值：要么是true，要么false。

代码实例

public class Test{
        public static void main(String[] args){
                // 逻辑与 ：& 规律：只要有一个操作数是false，那么结果一定是false
                System.out.println(true&true);
                System.out.println(true&false);
                System.out.println(false&false);
                System.out.println(false&true);
                
                // 短路与：&& 规律：效率高一些，只要第一个表达式是false，那么第二个表达式就不用计算了，结果一定是false
                System.out.println(true&&true);
                System.out.println(true&&false);
                System.out.println(false&&false);
                System.out.println(false&&true);
                
                // 逻辑或：| 规律：只要有一个操作数是true，那么结果一定是true
                System.out.println(true|true);
                System.out.println(true|false);
                System.out.println(false|false);
                System.out.println(false|true);
                
                // 短路或：|| 规律：效率高一些，只要第一个表达式是true，那么第二个表达式就不用计算了，结果一定是true
                System.out.println(true||true);
                System.out.println(true||false);
                System.out.println(false||false);
                System.out.println(false||true);
                
                //逻辑非：   !  规律：相反结果
                System.out.println(!true);//false
                System.out.println(!false);//true
                
                //逻辑异或： ^  规律：两个操作数相同，结果为false，不相同，结果为true
                System.out.println(true^true);
                System.out.println(true^false);
                System.out.println(false^false);
                System.out.println(false^true);
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

6 位运算符： &，|，^，~ ， >>，<<，>>>

如何区分逻辑运算符和位运算符

1. 逻辑运算符：左右连接的是布尔类型的操作数。
2. 位运算符： 左右连接的是具体的数值。

有符号左移 <<

   EG: 3<<2 = 12 （相当与$3\ast 2^2=12$）

  面试题： 4乘以8最快的方式： 4<<3 （相当于$4\ast 2^3=32$）

有符号右移 >>

  EG: 6>>2 = 1（相当与$\frac{6}{2^2}=1$）

  EG：-6>>2 = -2

无符号右移 >>>

和有符号不同的是，有符号的如果最边上是1，那就补1，而无符号右移是无论左边是0还是1都一定补0

EG：6>>>2 = 1

各个位运算的定义

1. & 与运算（相同为1，不同为0）
2. | 或运算（有1为1，没有1为0）
3. ^ 异或运算 （相同为0，不同为1，可以看成是无进制相加）
4. ~ 取反操作 （原为0的变为1，原本为1的变为0）

小问题：为什么byte的范围是-128到127：
  127： 01111111
  -128： 10000000（负数在内存中是以补码的形式存放的）
  首先取反：一看就是个负数
  减1： 01111111
  取反： 10000000 —> 2^7 = 128
  加负号： -128

7 条件运算符(三目运算符)： A ? B : C

其中A是一个布尔类型的表达式，返回结果要么是true要么false，通过a的结果决定最终表达式的结果:
  如果A的结果是true， 那么表达式最终结果为B
  如果A的结果是false，那么表达式最终结果为C

/**
 * 条件运算符(三目运算符)： A ? B : C
 **/
public class demo5 {
    public static void main(String[] args) {
        int num = (5 > 7) ? 6 : 9;
        System.out.println(num); // 输出：9

        System.out.println((4 == 4) ? "你好" : "你不好"); // 输出：你好
    }
}
1
2
3
4
5
6
7
8
9
10
11