Java运算符

一. 赋值运算符

赋值运算符的符号为 “=” ，它的作用是将数据，变量或对象赋值给相应类型的变量或对象，例如下面的代码：

int i = 75;                         //将数据赋值给变量
long l = i;                         //将变量赋值给变量
Object object = new Object();       //创建对象

二. 算术运算符

运算符	功能	举例	运算结果	结果类型
+	加法运算	10 + 7.5	17.5	double
-	减法运算	10 - 7.5F	2.5F	float
*	乘法运算	3 * 7	21	int
/	除法运算	21 / 3L	7L	long
%	求余运算	10 * 3	1	int

三. 关系运算符

运算符	功能	举例	运算结果	可运算数据类型
>	大于	‘a’ > ‘b’	false	整数型、浮点数型、字符型
<	小于	2 < 3.0	true	整数型、浮点数型、字符型
==	等于	‘X’ == 88	true	所有数据类型
!=	不等于	true != true	false	所有数据类型
>=	大于或等于	6.6 >= 8.8	false	整数型、浮点数型、字符型
<=	小于或等于	‘M’ <= 88	true	整数型、浮点数型、字符型

四. 逻辑运算符

1. 运算符 “!”

运算符 “!” 用于对逻辑值进行取反运算。当逻辑值为 true 时，经过取反运算后运算结果为 false；当逻辑值为 false；当逻辑值为 false 时，经过取反运算后运算结果则为 true。

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(!true);   //输出值为 false  
        System.out.println(!false);  //输出值为 true  

    }
}

2. 运算符 “^”

运算符 “^” 用于对逻辑值进行异或运算。当运算符的两侧同时为 true 或 false 时，运算结果为 false，否则运算结果为 true。

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(true ^ true);    //输出值为 false
        System.out.println(true ^ false);   //输出值为 true
        System.out.println(false ^ true);   //输出值为 true
        System.out.println(false ^ false);  //输出值为 false
    }
}

3. 运算符 “&&” 和 “&”

运算符 “&&” 和 “&” 均用于逻辑与运算。当运算符的两侧同时为 true 时，运算结果为 true，否则运算结果均为 false。

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(true & true);    //输出值为 true 
        System.out.println(true & false);   //输出值为 false 
        System.out.println(false & true);   //输出值为 false 
        System.out.println(false & false);  //输出值为 false 

        System.out.println(true && true);   //输出值为 true 
        System.out.println(true && false);  //输出值为 false 
        System.out.println(false && true);  //输出值为 false 
        System.out.println(false && false); //输出值为 false 
    }
}

4. 运算符 “||” 和 “|”

运算符 “||” 和 “|” 均用于逻辑或运算。当运算符的两侧同时为 false 时，运算结果为 false，否则运算结果均为 true。

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(true | true);    //输出值为 true
        System.out.println(true | false);   //输出值为 true
        System.out.println(false | true);   //输出值为 true
        System.out.println(false | false);  //输出值为 false

        System.out.println(true || true);   //输出值为 true
        System.out.println(true || false);  //输出值为 true
        System.out.println(false || true);  //输出值为 true
        System.out.println(false || false); //输出值为 false
    }
}

五. 位运算符

1. 逻辑位运算符

~（按位取反）
&（按位与）
|（按位或）
^（按位异或）

操作数 x	操作数 y	~x	x & y	x | y	x ^ y
0	0	1	0	0	0
0	1	1	0	1	1
1	0	0	0	1	1
1	1	0	1	1	0

按位取反运算是将二进制位中的0修改为1，1修改为0；
在进行按位与运算时，只有当两个二进制位都为1时，结果才为1；
在进行按位或运算时，只要有一个二进制位为1，结果就为1；
在进行按位异或运算时，当两个二进制位同时为0或1时，结果为0，否则结果为1。

public class Demo02 {
    public static void main(String[] args) {
        int a = 5 & -4;
        int b = 3 | 6;
        int c = 10 ^ 3;
        int d = ~(-14);

        System.out.println(a);  //输出值为 4
        System.out.println(b);  //输出值为 7
        System.out.println(c);  //输出值为 9
        System.out.println(d);  //输出值为 13
    }
}

2. 移位运算符

“<<（左移，低位添0补齐）”
“>>（右移，高位添符号位）”
“>>>（右移，高位添0补齐）”

public class Demo02 {
    public static void main(String[] args) { 
        int a = -2 << 3;
        int c = 15 >> 2;
        int e = 4 >>> 2;
        int f = -5 >>> 1;

        System.out.println(a);  //输出值为 -16 
        System.out.println(c);  //输出值为 3 
        System.out.println(e);  //输出值为 1 
        System.out.println(f);  //输出值为 2147483645 
    }
}

六. 其他运算符

1. 自动递增

1.1 ++ 出现在变量的前面

当++出现在变量的前面时，会先将变量的值加1，然后再使该变量参与表达式的运算。

1.2 ++ 出现在变量的后面

当++出现在变量的后面时，会先使变量参与表达式的运算，然后再将该变量加1。

public class Demo01 {
    public static void main(String[] args) { 
        int a = 3;
        
        int b = a++;  //执行完这行代码后，先给b赋值，再自增,相当于先执行b=a;再执行a=a+1; 
        
        System.out.println(a);  //输出结果为 4 
        
        int c = ++a;  //执行完这行代码前，先自增，再给c赋值,相当于先执行a=a+1;再执行c=a; 
        
        System.out.println(a);  //输出结果为 5 
        System.out.println(b);  //输出结果为 3 
        System.out.println(c);  //输出结果为 5 
    }
}

2. 自动递减

1.1 -- 出现在变量的前面

当 -- 出现在变量的前面时，会先将变量的值减1，然后再使该变量参与表达式的运算。

1.2 -- 出现在变量的后面

当 -- 出现在变量的后面时，会先使变量参与表达式的运算，然后再将该变量减1。

public class Demo01 {
    public static void main(String[] args) {
        int a = 3;

        int b = a--;  //执行完这行代码后，先给b赋值，再自减,相当于先执行b=a;再执行a=a-1; 

        System.out.println(a);  //输出结果为 2

        int c = --a;  //执行完这行代码前，先自减，再给c赋值,相当于先执行a=a-1;再执行c=a;

        System.out.println(a);  //输出结果为 1
        System.out.println(b);  //输出结果为 3
        System.out.println(c);  //输出结果为 1
    }
}

3. 三元运算符

逻辑表达式 ? 表达式 1 : 表达式 2

逻辑表达式的结果为 true 时，表达式1的执行结果作为整个表达式的结果。
逻辑表达式的结果为 false 时，表达式2的执行结果作为整个表达式的结果。

public class Demo02 {
    public static void main(String[] args) {
        int store = 12;
        System.out.println(store <= 5? "库存不足！" : "库存量：" +store);//输出结果为 "库存量：12"  
    }
}

4. 扩展赋值运算符

+=
-=
*=
/=

public class Demo02 { 
    public static void main(String[] args) { 
        int a = 2; 
        int b = 4; 
        int c = 6; 
        int d = 8; 
        int e = 10; 
        b += a; //相当于 b = b + a; 
        c -= a; //相当于 c = c - a; 
        d *= a; //相当于 d = d * a; 
        e /= a; //相当于 e = e / a; 
        System.out.println(b);  //输出值为 6 
        System.out.println(c);  //输出值为 4 
        System.out.println(d);  //输出值为 16 
        System.out.println(e);  //输出值为 5 
    }
}