Java SE(2)——运算符-优快云博客

本文链接：https://blog.youkuaiyun.com/2401_89167985/article/details/147125132

1.运算符

1.1概念

在Java编程语言中，运算符(Operators) 是用于特定操作的符号，它们用于对变量和值进行各种操作

1.2算数运算符

1.2.1基本四则运算符( + - * / % )

		//1.基本四则运算符
        int a = 25;
        int b = 10;
        int c = a + b;
        System.out.println(c);//35
        int d = a - b;
        System.out.println(d);//15
        int e = a * b;
        System.out.println(e);//250
        int f = a / b;
        System.out.println(f);//2
        int g = a % b;//相当于数学中进行除法后的余数
        System.out.println(g);//5

四则运算符是二元运算符，左右操作数必须同时存在
int / int 的结果还是int类型，并且会向下取整

int a = 10;
int b = 0;
抛出异常：Exception in thread "main" java.lang.ArithmeticException: / by zero

进行除法运算时，除数(右操作数)不能为0

//int + double = double
System.out.println(1 + 0.2);//1.2

当左右操作数类型不一致时，向类型⼤的提升

1.2.2.赋值运算符( = += -= *= /= )

		//2.赋值运算符
		a = 50;//把50赋值给a变量
        System.out.println(a);
        a += 2;//相当于a = a + 2;
        System.out.println(a);
        a -= 2;//相当于a = a - 2;
        System.out.println(a);
        a *= 2;//相当于a = a * 2;
        System.out.println(a);
        a /= 2;//相当于a = a / 2;
        System.out.println(a);

		int x = 10;
        double y = 20;
        x += y;//不报错，相当于x = (int)x + y
        x = x + y;//报错

赋值运算符在计算的时候，可以不进行强制(显式)类型转换

1.2.3自增/减运算符

		//3.自增/减运算符
        a--;//相当于a = a - 1;
        System.out.println(a);
        a++;//相当于a = a + 1;
        System.out.println(a);

像上面a变量单独使用时，前置和后置自增/减没有区别；但是像下面a变量和其他代码混合使用时，就有区别了

		int i = 100;
        System.out.println(i++);//先打印i的值，再++，输出100
        i = 100;
        System.out.println(++i);//先++，再打印i的值，输出101

前置自增/减运算符：先运算，再使用
后置自增/减运算符：先使用，再运算

1.3关系运算符( == > >= < <= != )

关系运算符的计算结果是boolean类型

		//关系运算符
        int a = 25;
        int b = 10;
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        System.out.println(a < b);//false
        System.out.println(a > b);//true
        System.out.println(a <= b);//false
        System.out.println(a != b);//true

		int a = 25;
        int b = 10;
        int c = 20;
        System.out.println(b < c < a);

当需要多次判断时，不能连着写，上述b < c < a是不符合Java语法规定的

1.4逻辑运算符( && || ! )

逻辑运算符的计算结果是boolean类型

1.4.1逻辑与 &&

使用条件：左右表达式的结果必须是boolean
处理结果：左右表达式全为true时结果为true；其余结果为false

表达式1	表达式2	结果
true	true	true
true	false	false
false	true	false
false	false	false

1.4.2逻辑或 ||

使用条件：左右表达式的结果必须是boolean
处理结果：左右表达式全为false时结果为false；其余结果为true

表达式1	表达式2	结果
true	true	true
true	false	true
false	true	true
false	false	false

1.4.3逻辑非 !

处理结果：真变假，假变真

表达式	!表达式
true	false
false	true

1.4.4 短路求值

短路求值时&&和||运算符的运算规则

		int a = 25;
        int b = 10;
        //a == b的结果已经是false时,将不会再处理a / 0 == 0表达式,所以不报错
        System.out.println(a == b && a / 0 == 0);
        //a != b的结果已经是true时,将不会再处理a / 0 == 0表达式,所以不报错
        System.out.println(a != b || a / 0 == 0);

1.5位运算符

用于对数据的二进制位进行操作，位运算符有&，|，^，~四个。其中 ~是一元运算符，其他三个是二元运算符

1.5.1按位与 &

运算规则：全1为1，有0为0

		byte a = 5; //0000 0101
        byte b = 10;//0000 1010
        //  &
        byte c = (byte) (a & b);
        System.out.println(c);//0000 0000

1.5.2按位或 |

运算规则：全0为0，有1为1

		byte a = 5; //0000 0101
        byte b = 10;//0000 1010
        //  |
        byte d = (byte) (a | b);
        System.out.println(d);//0000 1111

1.5.1按位异或 ^

运算规则：相同为0，不同为1

		byte a = 5; //0000 0101
        byte b = 10;//0000 1010
        //  ^
        System.out.println(a ^ b);//0000 1111

1.5.1按位取反 ~

运算规则：0为1，1为0

		//  ~
		byte e = 127;//0 1111111
        System.out.println(e);
        //计算结果是-128
        System.out.println(~e);//1 0000000

1.6移位运算符

移位运算符有三个，都是二元运算符，且都是按照⼆进制⽐特位来运算的

1.6.1 左移<<

最左侧位不要了, 最右侧补0

		// <<
		byte a = 15;//0 0001111
        //向左移一位
        System.out.println(a << 1);//0 0011110

1.6.2 右移>>

最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

		// >>
        byte b = 15; //0 0001111
        byte c = -15;//原码1 0001111
                     //反码1 1110000
                     //补码1 1110001
        //向右移一位
        System.out.println(b >> 1);//0 0000111
        //原码1 0000111结果是-8
        System.out.println(c >> 1);//补码1 1111000
                                   //反码1 1110111
                                   //原码1 0001000

1.7条件运算符

语法格式：表达式1 ? 表达式2 : 表达式3
当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;
当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值

		int a = 25;
        int b = 10;
        //a > b 表达式的结果时true,所以max的值为a
        int max = a > b ? a : b;
        System.out.println(max);
        //a < b 表达式的结果时false,所以min的值为b
        int min = a < b ? a : b;
        System.out.println(min);

1.8本文使用的所有代码

public class Operators {
    public static void main1(String[] args) {
        //1.基本四则运算符
        int a = 25;
        int b = 10;
        int c = a + b;
        System.out.println(c);//35
        int d = a - b;
        System.out.println(d);//15
        int e = a * b;
        System.out.println(e);//250
        int f = a / b;
        System.out.println(f);//2
        int g = a % b;//相当于数学中进行除法后的余数
        System.out.println(g);//5
        //2.赋值运算符
        a = 50;//把50赋值给a变量
        System.out.println(a);
        a += 2;//相当于a = a + 2;
        System.out.println(a);
        a -= 2;//相当于a = a - 2;
        System.out.println(a);
        a *= 2;//相当于a = a * 2;
        System.out.println(a);
        a /= 2;//相当于a = a / 2;
        System.out.println(a);
        //3.自增/减运算符
        a--;//相当于a = a - 1;
        System.out.println(a);
        a++;//相当于a = a + 1;
        System.out.println(a);
        int i = 100;
        System.out.println(i++);//先打印i的值，再++，输出100
        i = 100;
        System.out.println(++i);//先++，再打印i的值，输出101
    }

    public static void main2(String[] args) {
        //关系运算符
        int a = 25;
        int b = 10;
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        System.out.println(a < b);//false
        System.out.println(a > b);//true
        System.out.println(a <= b);//false
        System.out.println(a != b);//true
    }

    public static void main3(String[] args) {
        //逻辑运算符
        int a = 25;
        int b = 10;
        //a == b的结果已经是false时,将不会再处理a / 0 == 0表达式,所以不报错
        System.out.println(a == b && a / 0 == 0);
        //a != b的结果已经是true时,将不会再处理a / 0 == 0表达式,所以不报错
        System.out.println(a != b || a / 0 == 0);
    }

    public static void main4(String[] args) {
        //位运算符
        byte a = 5; //0000 0101
        byte b = 10;//0000 1010
        //  &
        byte c = (byte) (a & b);
        //  |
        byte d = (byte) (a | b);
        System.out.println(c);//0000 0000
        System.out.println(d);//0000 1111
        //  ^
        System.out.println(a ^ b);//0000 1111
        //  ~
        byte e = 127;//0 1111111
        System.out.println(e);
        //计算结果是-128
        System.out.println(~e);//1 0000000
    }

    public static void main5(String[] args) {
        //移位运算符
        // <<
        byte a = 15;//0000 1111
        //向左移一位
        System.out.println(a << 1);//0001 1110

        // >>
        byte b = 15; //0 0001111
        byte c = -15;//原码1 0001111
                     //反码1 1110000
                     //补码1 1110001
        //向右移一位
        System.out.println(b >> 1);//0 0000111
        //原码1 0000111结果是-8
        System.out.println(c >> 1);//补码1 1111000
                                   //反码1 1110111
                                   //原码1 0001000
    }

    public static void main6(String[] args) {
        int a = 25;
        int b = 10;
        //a > b 表达式的结果时true,所以max的值为a
        int max = a > b ? a : b;
        System.out.println(max);
        //a < b 表达式的结果时false,所以min的值为b
        int min = a < b ? a : b;
        System.out.println(min);
    }
}