四、Java之运算符

一、算术运算符

1.1 算术运算符介绍

算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多

1.2 算术运算符一览

1.3 算术运算符使用

// 算术运算符
public class ArithmeticOperator {
    public static void main(String[] args) {

        // 1. + - * / 运算符
        System.out.println(10 / 4); // 2   int / int == int，所以最后是2
        System.out.println(10.0 / 4); // 2.5
        double d = 10 / 4;  // 10 /4 == 2, 因为保存成了double类型，所以d = 2.0
        System.out.println(d); // 2.0

        // 2. % 取模(取余) % 本质: a % b = a - a / b * b;  如果a是小数， a % b = a - int(a) / b * b
        System.out.println(10 % 3); // 1 
        System.out.println(-10 % 3); // -1 == -10 - (-10) / 3 * 3 == -10 + 9 = -1
        System.out.println(10 % -3); // 1 == 10 - 10 / (-3) * (-3) == 1
        System.out.println(-10 % -3); // -1 == -10 - (-10) / (-3) * (-3) == -1
         System.out.println(-10.5 % 3); // -1.5  == -10.5 - int(-10.5) / 3 * 3 == -10.5 + 9 == -1.5
                        // -10.5 % 3 == -[(10.5)-(int)(10.5) /3 * 3] == -(10.5 - 9) == -1.5
        
        // 3. 作为表达式使用 ++ --
        // 作为表达式独立语句使用 前++和后++都完全等价于 i=i+1;
        int i = 10;
        i++; // i = i+1 ==> i = 11
        ++i; // i = i+1 ==> i = 12
        System.out.println(i); // 12
        // 作为表达式赋值使用
        // 前++：++i 先自增后赋值
        // 后++：i++先赋值后自增
        int j = 10;
        int m = ++j; // j = j+1;  m = j;  j = 11; m = 11
        int n = j++; // n = j;  j = j+1;  n = 11; j = 12
        System.out.println("m = " + m + "  n = " + n + "   j = " + j); // m = 11  n = 11   j = 12
         i= 66;
         System.out.println(++i+i); // i = i + 1 = 67   67 + i == 67 + 67 == 134
         // 4. + 作为字符串相加使用
         https://www.cnblogs.com/wangyong123/articles/17844537.html#_label1
    }
}

 

public class ArithmeticOperatorExercise {
    public static void main(String[] args) {
        // 1. ++ 练习 输出的结果是什么？
        int i = 10;
        i = i++; // 规则使用临时变量: (1) temp=i; (2) i=i+1; (3)i=temp;
        System.out.println("i = " + i); // i = 10

        // 2.  假如还有 59 天放假，问：合 xx 个星期零 xx 天
        int d = 59;
        int x = 59 / 7;
        int t = 59 % 7;
        System.out.println(x + "个星期" + t + "天"); // 8个星期3天

        // 3. 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。
        double huaShi = 1234.6;
        double sheShi = 5.0 / 9 * (huaShi - 100);  // 如果5/9=0, 所以需要改成double或者float类型
        System.out.println("摄氏温度" + sheShi); // 摄氏温度630.3333333333333
    }
}

二、关系运算符

2.1 关系运算符介绍

1. 关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false
2. 关系表达式 经常用在 if 结构的条件中或循环结构的条件中

2.2 关系运算符一览表

 

public class RelationalOperator {
    public static void main(String[] args) {
        int a = 9;
        int b = 8;
        System.out.println(a > b);  // true
        System.out.println(a >= b); // true
        System.out.println(a <= b); // flase
        System.out.println(a < b);  // flase
        System.out.println(a == b); // flase
        System.out.println(a != b); // true
    }
}

三、逻辑运算符

3.1 逻辑运算符介绍

用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。

3.2 逻辑运算符一览表

3.2.3 逻辑运算符(&、|、^)

1. a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false
2. a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
3. a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

3.2.4 短路运算符(&&、||、!)

1. a&&b: && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false
2. a||b: || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
3. !a: 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true

3.3 && 和 & 的使用区别

1. &&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
2. & 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低
3. 开发中， 我们使用的基本是使用短路与&&, 效率高

public class LogicOperator01 {
    public static void main(String[] args) {
        int age = 50;
        if(age > 20 && age < 90) {
            System.out.println("test &&"); // test &&
        }

        if(age > 20 & age < 90) {
            System.out.println("test &"); // test &
        }

        // 对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断
        // 对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断
        int a = 4;
        int b = 9;
        if (a < 1 & ++b < 50) {
            System.out.println("test &的使用规则"); 
        }
        System.out.println("a = " + a + ", b = " + b); // a = 4, b = 10

        a = 4;
        b = 9;
        if (a < 1 && ++b < 50) {
            System.out.println("test &&的使用规则"); 
        }
        System.out.println("a = " + a + ", b = " + b); // a = 1, b = 9
    }
}

3.4 || 与 | 的使用区别

1. ||短路或: 如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
2. | 逻辑或: 不管第一个条件是否为 true，第二个条件都要判断，效率低
3. 开发中，我们基本使用 ||

public class LogicOperator02 {
    public static void main(String[] args) {
        // || 规则: 两个条件中只要有一个成立，结果为 true,否则为 false
        // |  规则: 两个条件中只要有一个成立，结果为 true,否则为 false
        int age = 50;
        if (age > 20 || age < 30) {
            System.out.println("test ||"); // test ||
        }
        if (age > 20 | age < 30) {
            System.out.println("test |"); // test |
        }

        // ||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
        // | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
        int a = 4;
        int b = 9;
        if(a > 1 || ++b > 4) {
            System.out.println("test || 的使用规则"); // test || 的使用规则
        }
        System.out.println("a = " + a +", b = " + b); // a = 4, b = 9
        
        a = 4;
        b = 9;
        if(a > 1 | ++b > 4) {
            System.out.println("test | 的使用规则"); // test | 的使用规则
        }
        System.out.println("a = " + a +", b = " + b); // a = 4, b = 10
    }
}

3.5 ! 取反运算符的使用

! 非（取反） !条件 如果条件本身成立，结果为 false，否则为 true

public class InverseOperator {
    public static void main(String[] args) {
        System.out.println(60 > 20);    // true
         System.out.println(!(60 > 20)); // false
    }
}

3.6 ^ 异或运算符的使用

a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

public class InverseOperator {
    public static void main(String[] args) {
        boolean b = (10 > 1) ^ (3 > 5);
        System.out.println(b); // true
    }
}

3.7 练习

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

        // 1. & 
        int x = 5;
        int y = 5;
        if (x++ == 6 & ++y == 6) 
        {
            x = 11;
        }
        System.out.println("x = " + x +", y = " + y); // x = 6, y = 6

        // 2
        x = 5;
        y = 5;
        if (x++ == 6 && ++y == 6) 
        {
            x = 11;
        }
        System.out.println("x = " + x +", y = " + y); // x = 6, y = 5

        // 3. |
        x = 5;
        y = 5;
        if (x++ == 5 | ++y == 5) 
        {
            x = 11;
        }
        System.out.println("x = " + x +", y = " + y); // x = 11, y = 6

        // 4. ||
        x = 5;
        y = 5;
        if (x++ == 5 || ++y == 5) 
        {
            x = 11;
        }
        System.out.println("x = " + x +", y = " + y); // x = 11, y = 5
    }
}

 

public class Practice {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;
        short z = 46;
        if ((z++ == 46) && (y = true)) { // y = true 为赋值语句，返回y的值true
            z++;
        }
        if ((x = false) || (++z == 49)) { // x = false 为赋值语句，返回结果为x 的值false
            z++;
        }
        System.out.println("z = " + z);  // z = 50
    }
}

四、赋值运算符

4.1 赋值运算符介绍

赋值运算符就是将某个运算后的值，赋给指定的变量。

4.2 赋值运算符的分类

1. 基本赋值运算符: = int a = 10;
2. 复合赋值运算符: += ，-= ，*= ， /= ，%= 等

4.3 赋值运算符的特点

1. 运算顺序从右往左 int num = a + b + c;
2. 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值 int num = 20; int num2= 78 * 34 - 10;
int num3 = a;
3. 复合赋值运算符等价于下面的效果。比如：a+=3;等价于 a=a+3; 其他类推
4. 复合赋值运算符会进行类型转换。byte b = 2; b+=3; b++;

public class AssignOperator {
    public static void main(String[] args) {
        int n1 = 10;
        n1 += 4;
        System.out.println(n1); // 14
        n1 /= 3;
        System.out.println(n1); // 4

        // 复合赋值运算符会进行类型转换
        byte b = 3;
        b += 2; // b = (byte)(b + 2);
        b++; //b = (byte)(b + 1);
    }
}

五、三元运算符

5.1 基本语法

条件表达式 ? 表达式 1: 表达式 2;

运算规则：
1. 如果条件表达式为 true，运算后的结果是表达式 1；
2. 如果条件表达式为 false，运算后的结果是表达式 2；

public class TernaryOperator {
    public static void main(String[] args) {
        int a = 10;
        int b = 99;
        int result1 = a > b ? a++:b--; // int resule == b-- == 99
        System.out.println(result1); // 99
        a = 10;
        b = 99;
        int result2 = a < b ? a++:b--;
        System.out.println(result2); // 10
        System.out.println(a); // 11
        System.out.println(b);  // 99
    }
}

5.2 三元运算符的使用细节

1. 三元运算符可以转成 if--else 语句
2. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)

// 1.  三元运算符可以转成 if--else 语句
int res = a > b ? a++ : --b;
if (a > b) {
    res = a++;
} else {
    res = --b;
}

 

// 2. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
public class TernaryOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 8;
        int c = a > b ? (int)1.1 : (int)3.4; // 可以
        System.out.println(c); // 3
        double d = a > b ? a : b + 3;//可以，满足 int -> double

    }
}

 

public class TernaryOperator {
    public static void main(String[] args) {
        // 找出三个数的最大值
        int n1 = 55;
        int n2 = 33;
        int n3 = 123;
        int tmp = n1 > n2 ? n1 : n2;
        tmp = tmp > n3 ? tmp : n3;
        System.out.println("max is " + tmp);  // max is 123

        // int tmp2  = (n1 > n2 ? n1 : n2) > n3 ? (n1 > n2 ? n1 : n2) : n3; 一条语句，但是不清晰
    }
}

六、位运算符

6.1 原码、反码、补码

https://www.cnblogs.com/wangyong123/articles/13997795.html#_lab2_0_0

1. 二进制数的最高位是符号位: 0表示整数, 1表示负数
2. 正数的原码、反码、补码是一样的
3. 负数的反码 = 它的原码符号位不变, 其他位取反
4. 负数的补码 = 它的反码 + 1
5. 0 的反码、补码都是 0
6. Java没有无符号数, 换言之, Java中的数值都是有符号的
7. 在计算机运算的时候, 都是以补码的方式运算的
8. 当我们看运算的结果的时候, 看到的是它的原码

6.2 位运算符

java 中有 7 个位运算(& | ^ ~ >> << >>>)

1. 按位与 & : 两位全为1, 结果为1, 否则为0
2. 按位或 | : 两位有一位为1, 结果为1, 否则为0
3. 按位异或 ^ : 两位中有一个为1, 结果为1,,否则为0
4. 按位取反 ~ : 0->1 1->0
5. 算数右移 >> : 低位溢出,符号位不变,并用符号位补溢出的高位
6. 算数左移 >> : 符号位不变,低位补 0
7. 逻辑右移 >>> : 无符号右移, 低位溢出，高位补 0, 没有 <<< 符号

public class BitOperator {
    public static void main(String[] args) {
        int a = 1 >> 2;  // 0000 00001 -->  0000 0000  本质 1 / 2 / 2 =0
        System.out.println(a); // 0
        int b = 1 << 2;  // 0000 00001 -->  0000 0100  本质 1 * 2 * 2 = 4
        System.out.println(b); // 4
        System.out.println(4 << 3); // 2  4 * 2 * 2 *2 = 32
        System.out.println(15 >> 2); // 3 15 / 2 / 2 = 3

        System.out.println(2 & 3); // 2 2的补码:0000 0010, 3的补码:0000 0011, 2&3 == 00000010 == 2

        // -2的原码:     10000000 00000000 00000000 00000010
        // -2的反码:     11111111 11111111 11111111 11111101
        // -2的补码:     11111111 11111111 11111111 11111110
        // ~-2:          00000000 00000000 00000000 00000001
        // 运算后的原码: 00000000 00000000 00000000 00000001
        System.out.println(~-2); // 1

        // 2的补码:      00000000 00000000 00000000 00000010
        // ~2:           11111111 11111111 11111111 11111101
        // ~2的反码:     11111111 11111111 11111111 11111100   补码-1
        // 运算后的原码: 10000000 00000000 00000000 00000011   符号位不变
        System.out.println(~2); // -3
    }
}

七、 运算符优先级

1. 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。上一行运算符总优先于下一行。
2. 只有单目运算符、赋值运算符是从右向左运算的。

	.       ( )      { }      ;
R-->L	++      --      ~      !
L-->R	*        /       %
L-->R	+         -
L-->R	<<       >>        >>>      位移
L-->R	<       >     <=       >=       instanceof
L-->R	==         !=
L-->R	&
L-->R	^
L-->R	|
L-->R	&&
L-->R	||
L-->R	?        :
L-->R	=        *=          /=      %=
	+=             -=         <<=           >>=
	>>>=        &=        ^=            !=